package auxiliary;

import java.awt.Font;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JOptionPane;

import org.joda.time.DateTime;

import plantable.CellSpan;
import plantable.TableModelAttributiveCell;

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Element;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.pdf.ColumnText;
import com.itextpdf.text.pdf.PdfContentByte;
import com.itextpdf.text.pdf.PdfWriter;

public class Planner extends Thread {

	public int status[], currtime, dayindex, indicedia;
	public DateTime planday;
	public String month, year;

	public HashMap<Integer, Lote> lotes;
	public ArrayList<Integer> loteids;
	ArrayList<Lote> nextdaylotes;
	ArrayList<ArrayList<String>> listOfMensuales;
	
	int nextloteid;

	ArrayList<String> time;

	public boolean done;
	public boolean exists;
	String modo;

	int etiquetadomax;
	int bandasmax;
	int empacadomax;


	HashMap<String, ArrayList<String>> copyavaListOfMaquinariaProduccion;
	HashMap<String, ArrayList<String>> copyavaListOfMaquinariaLlenado;
	HashMap<String, ArrayList<String>> copyavaListOfMaquinariaLoteado;
	
	HashMap<String, ArrayList<String>> avaListOfMaquinariaProduccion;
	HashMap<String, ArrayList<String>> avaListOfMaquinariaLlenado;
	HashMap<String, ArrayList<String>> avaListOfMaquinariaLoteado;
	
	HashMap<String, ArrayList<String>> currListOfMaquinariaProduccion;
	HashMap<String, ArrayList<String>> currListOfMaquinariaLlenado;
	HashMap<String, ArrayList<String>> currListOfMaquinariaLoteado;
	
	
	HashMap<String, ArrayList<String>> copyavaListOfFuncionarios;
	HashMap<String, ArrayList<String>> avaListOfFuncionarios;
	HashMap<String, ArrayList<String>> currListOfFuncionarios;


	HashMap<String, ArrayList<String>> capacidaddeoperarLlenado; 
	HashMap<String, ArrayList<String>> capacidaddeoperarProduccion;
	HashMap<String, ArrayList<String>> capacidaddeoperarLoteado; 

	HashMap<String, ArrayList<String>> maquinasPuedenLlenar; 
	HashMap<String, ArrayList<String>> maquinasPuedenProducir;
	HashMap<String, ArrayList<String>> maquinasPuedenLotear; 


	Database db;
	public TableModelAttributiveCell ml;
	public CellSpan cellAtt;

	public class LoteIds implements Comparable {

		int loteid;
		int lastfase;
		int lastday;
		
		public LoteIds(int loteid, int lastfase, int lastday) {
			super();
			this.loteid = loteid;
			this.lastfase = lastfase;
			this.lastday = lastday;
		}
		
		public void setLastFase(int fase) {
			this.lastfase = fase;
		}
		
		public int getLastFase() {
			return lastfase;
		}

		
		@Override
		public int compareTo(Object anotherLote) throws ClassCastException {
		    if (!(anotherLote instanceof LoteIds))
		      throw new ClassCastException("A Lote object expected.");
		    int anotherLoteLastFase = ((LoteIds) anotherLote).getLastFase();  
		    return this.lastfase - anotherLoteLastFase;    
		  }
		
	}
	
	public class Lote extends Object {
		public int loteday;
		int startingfase;
		int lotehora;
		int loteid;
		int litros;
		int unidades;
		int status;
		public int donedia;

		String productid;
		String productname;
		String produccionid;

		int duracionetiquetado;
		float duraciontotaletiquetado;
		int duracionbandas;
		float duraciontotalbandas;
		int duracionempaque;
		float duraciontotalempaque;


		public ArrayList<Slot> dispensacion;
		public ArrayList<Slot> produccion;
		public HashMap<Integer, Slot> llenado;
		public HashMap<Integer, Slot> loteado;
		public HashMap<Integer, ArrayList<Slot>> etiquetado;
		public HashMap<Integer, ArrayList<Slot>> bandas;
		public HashMap<Integer, ArrayList<Slot>> empaque;

		boolean requiereloteado;
		boolean requiereetiquetado;
		boolean requierebandas;

		int nextfase;
		int currentfase;
		int lastfase;
		boolean islastfasefinalizada;
		
		int[] etindex;
		int[] banindex;
		int[] empindex;
		boolean currentfasestatus;
		boolean fasespending;
		public boolean done;
		public int nextfaseday;
		public int nextfasehour;
		boolean lastfasecheck;


		public Lote(int loteid, int lotehora, int loteday, String produccionid, int litros, int unidades,
				String productid, String productname, boolean done, int donedia, int startingfase) {
			//super();
			Database lotedb = new Database();
			lastfasecheck = false;
			this.lotehora = lotehora;
			this.litros = litros;
			this.productid = productid;
			this.productname = productname;
			this.done = done;
			this.unidades = unidades;
			this.produccionid = produccionid;
			this.fasespending = false;
			this.donedia = donedia;
			status = 0;
			this.startingfase = startingfase;

			duracionetiquetado = 0;
			duracionbandas = 0;
			duracionempaque = 0;


			dispensacion = new ArrayList<Slot>();
			produccion = new ArrayList<Slot>();
			llenado = new HashMap<Integer, Slot>();
			loteado = new HashMap<Integer, Slot>();
			etiquetado = new HashMap<Integer, ArrayList<Slot>>();
			bandas = new HashMap<Integer, ArrayList<Slot>>();
			empaque = new HashMap<Integer, ArrayList<Slot>>();

			requiereloteado = lotedb.retrieveProductoRequiereLoteado(productid);
			requiereetiquetado = lotedb.retrieveProductoRequiereEtiquetado(productid);
			requierebandas = lotedb.retrieveProductoRequiereBandas(productid);

			nextfase = 0;
			currentfase = 0;
			etindex = new int[6];
			Arrays.fill(etindex,0);
			banindex = new int[6];
			Arrays.fill(banindex,0);
			empindex = new int[6];
			Arrays.fill(empindex,0);
			currentfasestatus = false;

			this.loteday = loteday;
			this.loteid = loteid;
			this.lastfase = -1;
			this.islastfasefinalizada = true;
			
			lotedb.closeConnection();
		}
		
		public Lote(Lote lote) {
			this.lastfasecheck = lote.lastfasecheck;
			this.startingfase = lote.startingfase;
			this.lotehora = lote.lotehora;
			this.litros = lote.litros;
			this.productid = lote.productid;
			this.productname = lote.productname;
			this.done = lote.done;
			this.unidades = lote.unidades;
			this.produccionid = lote.produccionid;
			this.fasespending = lote.fasespending;
			this.donedia = lote.donedia;
			this.status = lote.status;

			this.duracionetiquetado = lote.duracionetiquetado;
			this.duracionbandas = lote.duracionbandas;
			this.duracionempaque = lote.duracionempaque;


			dispensacion = (ArrayList<Slot>) lote.dispensacion.clone();
			produccion = (ArrayList<Slot>) lote.produccion.clone();
			llenado = (HashMap<Integer, Slot>) lote.llenado.clone();
			loteado = (HashMap<Integer, Slot>) lote.loteado.clone();
			etiquetado = (HashMap<Integer, ArrayList<Slot>>) lote.etiquetado.clone();
			bandas = (HashMap<Integer, ArrayList<Slot>>) lote.bandas.clone();
			empaque = (HashMap<Integer, ArrayList<Slot>>) lote.empaque.clone();

			requiereloteado = lote.requiereloteado;
			requiereetiquetado = lote.requiereetiquetado;
			requierebandas = lote.requierebandas;

			nextfase = lote.nextfase;
			currentfase = lote.currentfase;
			etindex = lote.etindex;
			banindex = lote.banindex;
			empindex = lote.empindex;
			currentfasestatus = lote.currentfasestatus;

			this.loteday = lote.loteday;
			this.loteid = lote.loteid;
			this.lastfase = lote.lastfase;
			this.islastfasefinalizada = lote.islastfasefinalizada;
		}
		
		public void setStartingFase(int startingfase) {
			this.startingfase = startingfase;
		}
		
		public int getStartingFase() {
			return startingfase;
		}
		
		public Lote cloneLote() {
			try {
				return (Lote) this.clone();
			} catch (CloneNotSupportedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return null;
		}

		private int setupDispensacionSlot(String maquinaid, String maquinaname,
				ArrayList<String> funcionariouno,
				ArrayList<String> funcionariodos, int startime, boolean confirm, 
				int unidadesanteriores,int unidadesslot, int unidadespendientes) {

			ArrayList<String> maquinariaid = new ArrayList<String>();
			maquinariaid.add(maquinaid);
			ArrayList<String> maquinarianame = new ArrayList<String>();
			maquinarianame.add(maquinaname);
			ArrayList<String> personalname = new ArrayList<String>();
			personalname.add(funcionariouno.get(2) + ","
					+ funcionariouno.get(3));
			personalname.add(funcionariodos.get(2) + ","
					+ funcionariodos.get(3));
			ArrayList<String> personalid = new ArrayList<String>();
			personalid.add(funcionariouno.get(0));
			personalid.add(funcionariodos.get(0));

			////System.out.println("productid = " + productid);
			float duracion = db.retrieveProductoDuracionDispensacion(productid);
			int endtime = (startime + ((int) (duracion * 10))) - 1;

			if(confirm) {
			dispensacion.add(new Slot(loteday, year, month, startime, endtime,
					maquinariaid.get(0), maquinarianame.get(0), personalid,
					personalname, 1, true,
					unidadesanteriores,unidadesslot,unidadespendientes));
			}

			return endtime;

		}
		
		public void setupFakeDispensacionSlot(String maquinaid, String maquinaname) {

			ArrayList<String> maquinariaid = new ArrayList<String>();
			ArrayList<String> maquinarianame = new ArrayList<String>();
			ArrayList<String> personalname = new ArrayList<String>();
			ArrayList<String> personalid = new ArrayList<String>();
			
			maquinariaid.add(maquinaid);
			maquinarianame.add(maquinaname);

			////System.out.println("productid = " + productid);
			float duracion = 0;
			int endtime = 0;

			dispensacion.add(new Slot(loteday, year, month, 0, endtime,
					maquinaid, maquinaname, personalid,
					personalname, 1, true,0,0,0));
			
		}

		private int setupProduccionSlot(String maquinaid, String maquinaname,
				ArrayList<String> funcionariouno,
				ArrayList<String> funcionariodos, int startime, boolean confirm,
				int unidadesanteriores,int unidadesslot, int unidadespendientes) {

			ArrayList<String> maquinariaid = new ArrayList<String>();
			maquinariaid.add(maquinaid);
			ArrayList<String> maquinarianame = new ArrayList<String>();
			maquinarianame.add(maquinaname);
			ArrayList<String> personalname = new ArrayList<String>();
			personalname.add(funcionariouno.get(2) + ","
					+ funcionariouno.get(3));
			personalname.add(funcionariodos.get(2) + ","
					+ funcionariodos.get(3));
			ArrayList<String> personalid = new ArrayList<String>();
			personalid.add(funcionariouno.get(0));
			personalid.add(funcionariodos.get(0));

			float duracion = db.retrieveProductoDuracionProduccion(productid);
			// int endtime = (startime + ((int) (duracion * unidades * 10)));
			int endtime = (startime + ((int) (duracion * 10))) - 1;
			if(confirm) {
				produccion.add(new Slot(loteday, year, month, startime, endtime,
					maquinariaid.get(0), maquinarianame.get(0), personalid,
					personalname, 2, true,
					unidadesanteriores,unidadesslot,unidadespendientes));
			}

			return endtime;
		}
		
		public void setupFakeProduccionSlot(String maquinaid, String maquinaname) {

			ArrayList<String> maquinariaid = new ArrayList<String>();
			ArrayList<String> maquinarianame = new ArrayList<String>();
			ArrayList<String> personalname = new ArrayList<String>();
			ArrayList<String> personalid = new ArrayList<String>();

			maquinariaid.add(maquinaid);
			maquinarianame.add(maquinaname);

			float duracion = 0;
			int endtime = 0;
				produccion.add(new Slot(loteday, year, month, 0, endtime,
						maquinaid, maquinaname, personalid,
					personalname, 2, true,0,0,0));

		}

		private ArrayList<Integer> setupLlenadoSlot(String maquinaid, String maquinaname,
				ArrayList<ArrayList<String>> funcionarios, int startime,
				DateTime llenadoday, boolean confirm,
				int unidadesanteriores) {

			ArrayList<String> maquinariaid = new ArrayList<String>();
			maquinariaid.add(maquinaid);
			ArrayList<String> maquinarianame = new ArrayList<String>();
			maquinarianame.add(maquinaname);
			ArrayList<String> personalname = new ArrayList<String>();
			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}

			ArrayList<String> personalid = new ArrayList<String>();
			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}

			int slotunidades = unidades - unidadesanteriores;
			
			float duracion = db.retrieveProductoDuracionLlenado(slotunidades,
					maquinariaid.get(0), productid);
			
			int endtime = (startime + ((int) (duracion * 10))) - 1;

			int addday = 0;

			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}
			//System.out.println("addday = " + addday);

			if(llenadoday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = (llenadoday.getDayOfWeek() +addday) - (planday.getDayOfWeek() + 5);
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}


			if(confirm) {
				
			if (addday == 0) {
				llenado.put(llenadoday.getDayOfWeek(), (new Slot(llenadoday.getDayOfWeek(), year, month,
						startime, endtime, maquinariaid.get(0), maquinarianame
						.get(0), personalid, personalname, 3, true,
						unidadesanteriores,slotunidades,0)));
			} else if (addday == 1) {
				
				int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
				int secondunidades = slotunidades - firstunidades;
				
				llenado.put(llenadoday.getDayOfWeek(), (new Slot(llenadoday.getDayOfWeek(), year, month,
						startime, 99, maquinariaid.get(0), maquinarianame
						.get(0), personalid, personalname, 3, false,
						unidadesanteriores,firstunidades,secondunidades)));
				
				llenado.put(llenadoday.plusDays(1).getDayOfWeek(), (new Slot(llenadoday.plusDays(1).getDayOfWeek(), year,
						month, 0, endtime, maquinariaid.get(0), maquinarianame
						.get(0), personalid, personalname, 3, true,
						firstunidades,secondunidades,0)));
				
			} else if (addday > 1) {

				int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
				
				llenado.put(llenadoday.getDayOfWeek(), (new Slot(llenadoday.getDayOfWeek(), year, month,
						startime, 99, maquinariaid.get(0), maquinarianame
						.get(0), personalid, personalname, 3, false,
						unidadesanteriores,firstunidades,slotunidades-firstunidades)));
				
				int anteriores = firstunidades;
				
				for (int i = 1; i < addday; i++) {
					
					int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
					
					llenado.put(llenadoday.plusDays(i).getDayOfWeek(), (new Slot(llenadoday.plusDays(i).getDayOfWeek(), year,
							month, 0, 99, maquinariaid.get(0), maquinarianame
							.get(0), personalid, personalname, 3, false,
							anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades))));
					
					anteriores += siguientesunidades;
				}

				int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));
				
				llenado.put(llenadoday.plusDays(addday).getDayOfWeek(), (new Slot(llenadoday.plusDays(addday).getDayOfWeek(),
						year, month, 0, endtime, maquinariaid.get(0),
						maquinarianame.get(0), personalid, personalname, 3, true,
						anteriores,siguientesunidades,0)));
			}
			}

			ArrayList<Integer> var = new ArrayList<Integer>();
			var.add(endtime);
			var.add(addday);
			return var;
		}

		private ArrayList<Integer> setupLoteadoSlot(String maquinaid, String maquinaname,
				ArrayList<ArrayList<String>> funcionarios, int startime,
				DateTime loteadoday, boolean confirm,
				int unidadesanteriores) {

			ArrayList<String> maquinariaid = new ArrayList<String>();
			maquinariaid.add(maquinaid);
			ArrayList<String> maquinarianame = new ArrayList<String>();
			maquinarianame.add(maquinaname);
			ArrayList<String> personalname = new ArrayList<String>();
			
			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}

			ArrayList<String> personalid = new ArrayList<String>();
			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}

			int slotunidades = unidades - unidadesanteriores;
			
			float duracion = db.retrieveProductoDuracionLoteado(unidades,
					maquinariaid.get(0), productid);
		
			int endtime = (startime + ((int) (duracion * 10))) - 1;

			int addday = 0;

			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}

			if(loteadoday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = (loteadoday.getDayOfWeek() +addday) - (planday.getDayOfWeek() + 5);
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}
			
			if(confirm) {
				
				if (addday == 0) {
					loteado.put(loteadoday.getDayOfWeek(), (new Slot(loteadoday.getDayOfWeek(), year, month,
							startime, endtime, maquinariaid.get(0), maquinarianame
							.get(0), personalid, personalname, 4, true,
							unidadesanteriores,slotunidades,0)));
				} else if (addday == 1) {
					
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					int secondunidades = slotunidades - firstunidades;
					
					loteado.put(loteadoday.getDayOfWeek(), (new Slot(loteadoday.getDayOfWeek(), year, month,
							startime, 99, maquinariaid.get(0), maquinarianame
							.get(0), personalid, personalname, 4, false,
							unidadesanteriores,firstunidades,secondunidades)));
					
					loteado.put(loteadoday.plusDays(1).getDayOfWeek(), (new Slot(loteadoday.plusDays(1).getDayOfWeek(), year,
							month, 0, endtime, maquinariaid.get(0), maquinarianame
							.get(0), personalid, personalname, 4, true,
							firstunidades,secondunidades,0)));
					
				} else if (addday > 1) {

					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					
					loteado.put(loteadoday.getDayOfWeek(), (new Slot(loteadoday.getDayOfWeek(), year, month,
							startime, 99, maquinariaid.get(0), maquinarianame
							.get(0), personalid, personalname, 4, false,
							unidadesanteriores,firstunidades,slotunidades-firstunidades)));
					
					int anteriores = firstunidades;
					
					for (int i = 1; i < addday; i++) {
						
						int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
						
						loteado.put(loteadoday.plusDays(i).getDayOfWeek(), (new Slot(loteadoday.plusDays(i).getDayOfWeek(), year,
								month, 0, 99, maquinariaid.get(0), maquinarianame
								.get(0), personalid, personalname, 4, false,
								anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades))));
						
						anteriores += siguientesunidades;
					}

					int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));
					
					loteado.put(loteadoday.plusDays(addday).getDayOfWeek(), (new Slot(loteadoday.plusDays(addday).getDayOfWeek(),
							year, month, 0, endtime, maquinariaid.get(0),
							maquinarianame.get(0), personalid, personalname, 4, true,
							anteriores,siguientesunidades,0)));
				}
				}

			ArrayList<Integer> var = new ArrayList<Integer>();
			var.add(endtime);
			var.add(addday);
			return var;
		}

		private ArrayList<Integer> setupEtiquetadoSlot(ArrayList<ArrayList<String>> funcionarios, 
				int startime,
				DateTime etiquetadoday,
				boolean confirm,
				int unidadesanteriores) {

			ArrayList<String> personalname = new ArrayList<String>();

			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}

			ArrayList<String> personalid = new ArrayList<String>();

			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}

			int slotunidades = unidades - unidadesanteriores;
			
			float duracion = unidades/db.retrieveProductoDuracionEtiquetado(unidades, productid);

			int funcionariosize = funcionarios.size();
			int minimofuncionarios = 2;

			
			duracion = duracion * ((float) minimofuncionarios / funcionariosize);

			
			
			int endtime = (startime + ((int) (duracion * 10))) - 1;

			int addday = 0;

			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}

			if(etiquetadoday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = (etiquetadoday.getDayOfWeek() +addday) - (planday.getDayOfWeek() + 5);
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}
			
			if(confirm) {
			duraciontotaletiquetado = duracion;

			ArrayList<Slot> slotlist = new ArrayList<Slot>();

			if (addday == 0) {

				slotlist.add(new Slot(etiquetadoday.getDayOfWeek(), year, month,
						startime, endtime, personalid, personalname, 5, true,
						unidadesanteriores,slotunidades,0));

				etiquetado.put(etiquetadoday.getDayOfWeek(),slotlist);
			} else if (addday == 1) {

				int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
				int secondunidades = slotunidades - firstunidades;
				
				slotlist.add(new Slot(etiquetadoday.getDayOfWeek(), year, month,
						startime, 99, personalid, personalname, 5, false,
						unidadesanteriores,firstunidades,secondunidades));

				etiquetado.put(etiquetadoday.getDayOfWeek(), slotlist);

				slotlist = new ArrayList<Slot>();
				slotlist.add(new Slot(etiquetadoday.plusDays(1).getDayOfWeek(), year, month,
						0, endtime, personalid, personalname, 5, true,
						firstunidades,secondunidades,0));

				etiquetado.put(etiquetadoday.plusDays(1).getDayOfWeek(), slotlist);
			} else if (addday > 1) {

				int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
				
				slotlist.add(new Slot(etiquetadoday.getDayOfWeek(), year, month,
						startime, 99, personalid, personalname, 5, false,
						unidadesanteriores,firstunidades,slotunidades-firstunidades));

				etiquetado.put(etiquetadoday.getDayOfWeek(), slotlist);

				int anteriores = firstunidades;
				
				for (int i = 1; i < addday; i++) {
					
					int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
					
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(etiquetadoday.plusDays(i).getDayOfWeek(), year, month,
							0, 99, personalid, personalname, 5, false,
							anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades)));

					etiquetado.put(etiquetadoday.plusDays(i).getDayOfWeek(), slotlist);
				}
				
				int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));

				slotlist = new ArrayList<Slot>();
				slotlist.add(new Slot(etiquetadoday.plusDays(addday).getDayOfWeek(), year, month,
						0, endtime, personalid, personalname, 5, true,
						anteriores,siguientesunidades,0));

				etiquetado.put(etiquetadoday.plusDays(addday).getDayOfWeek(), slotlist);
			}
			}

			ArrayList<Integer> var = new ArrayList<Integer>();
			var.add(endtime);
			var.add(addday);
			return var;
		}

		private ArrayList<Integer> setupBandasSlot(ArrayList<ArrayList<String>> funcionarios, 
				int startime,
				DateTime bandasday,
				boolean confirm,
				int unidadesanteriores) {

			ArrayList<String> personalname = new ArrayList<String>();

			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}

			ArrayList<String> personalid = new ArrayList<String>();

			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}

			float duracion = unidades/db.retrieveProductoDuracionBandas(unidades, productid);
			
			int funcionariosize = funcionarios.size();
			int minimofuncionarios = 3;

			int slotunidades = unidades - unidadesanteriores;
			
			duracion = duracion * ((float) minimofuncionarios / funcionariosize);

			int endtime = (startime + ((int) (duracion * 10))) - 1;
			

			int addday = 0;

			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}

			if(bandasday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = (bandasday.getDayOfWeek() +addday) - (planday.getDayOfWeek() + 5);
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}


			if(confirm) {
				
				duraciontotalbandas = duracion;
				
				ArrayList<Slot> slotlist = new ArrayList<Slot>();

				if (addday == 0) {

					slotlist.add(new Slot(bandasday.getDayOfWeek(), year, month,
							startime, endtime, personalid, personalname, 6, true,
							unidadesanteriores,slotunidades,0));

					bandas.put(bandasday.getDayOfWeek(),slotlist);
				} else if (addday == 1) {

					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					int secondunidades = slotunidades - firstunidades;
					
					slotlist.add(new Slot(bandasday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 6, false,
							unidadesanteriores,firstunidades,secondunidades));

					bandas.put(bandasday.getDayOfWeek(), slotlist);

					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(bandasday.plusDays(1).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 6, true,
							firstunidades,secondunidades,0));

					bandas.put(bandasday.plusDays(1).getDayOfWeek(), slotlist);
				} else if (addday > 1) {

					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					
					slotlist.add(new Slot(bandasday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 6, false,
							unidadesanteriores,firstunidades,slotunidades-firstunidades));

					bandas.put(bandasday.getDayOfWeek(), slotlist);

					int anteriores = firstunidades;
					
					for (int i = 1; i < addday; i++) {
						
						int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
						
						slotlist = new ArrayList<Slot>();
						slotlist.add(new Slot(bandasday.plusDays(i).getDayOfWeek(), year, month,
								0, 99, personalid, personalname, 6, false,
								anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades)));

						bandas.put(bandasday.plusDays(i).getDayOfWeek(), slotlist);
					}
					
					int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));

					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(bandasday.plusDays(addday).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 6, true,
							anteriores,siguientesunidades,0));

					bandas.put(bandasday.plusDays(addday).getDayOfWeek(), slotlist);
			}
			}

			ArrayList<Integer> var = new ArrayList<Integer>();
			var.add(endtime);
			var.add(addday);
			return var;
		}
		
		private ArrayList<Integer> setupEmpaqueSlot(ArrayList<ArrayList<String>> funcionarios, 
				int startime,
				DateTime empaqueday,
				boolean confirm,
				int unidadesanteriores) {
		
			ArrayList<String> personalname = new ArrayList<String>();
		
			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}
		
			ArrayList<String> personalid = new ArrayList<String>();
		
			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}
		
			float duracion = unidades/db.retrieveProductoDuracionEmpaque(unidades, productid);
		
			int funcionariosize = funcionarios.size();
			int minimofuncionarios = 2;
		
			int slotunidades = unidades - unidadesanteriores;
			
			duracion = duracion * ((float) minimofuncionarios / funcionariosize);
			
		
			int endtime = (startime + ((int) (duracion * 10))) - 1;
			
		
			int addday = 0;
		
			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}
		
			if(empaqueday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = (empaqueday.getDayOfWeek() + addday) - (planday.getDayOfWeek() + 5);
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}
		
			if(confirm) {
				
				duraciontotalempaque = duracion;
		
				ArrayList<Slot> slotlist = new ArrayList<Slot>();

				if (addday == 0) {

					slotlist.add(new Slot(empaqueday.getDayOfWeek(), year, month,
							startime, endtime, personalid, personalname, 7, true,
							unidadesanteriores,slotunidades,0));

					empaque.put(empaqueday.getDayOfWeek(),slotlist);
				} else if (addday == 1) {

					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					int secondunidades = slotunidades - firstunidades;
					
					slotlist.add(new Slot(empaqueday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 7, false,
							unidadesanteriores,firstunidades,secondunidades));

					empaque.put(empaqueday.getDayOfWeek(), slotlist);

					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(empaqueday.plusDays(1).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 7, true,
							firstunidades,secondunidades,0));

					empaque.put(empaqueday.plusDays(1).getDayOfWeek(), slotlist);
				} else if (addday > 1) {

					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					
					slotlist.add(new Slot(empaqueday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 7, false,
							unidadesanteriores,firstunidades,slotunidades-firstunidades));

					empaque.put(empaqueday.getDayOfWeek(), slotlist);

					int anteriores = firstunidades;
					
					for (int i = 1; i < addday; i++) {
						
						int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
						
						slotlist = new ArrayList<Slot>();
						slotlist.add(new Slot(empaqueday.plusDays(i).getDayOfWeek(), year, month,
								0, 99, personalid, personalname, 7, false,
								anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades)));

						empaque.put(empaqueday.plusDays(i).getDayOfWeek(), slotlist);
					}
					
					int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));

					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(empaqueday.plusDays(addday).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 7, true,
							anteriores,siguientesunidades,0));

					empaque.put(empaqueday.plusDays(addday).getDayOfWeek(), slotlist);
			}
			}
		
		
			ArrayList<Integer> var = new ArrayList<Integer>();
			var.add(endtime);
			var.add(addday);
			return var;
		}


		private ArrayList<Integer> setupEtiquetadoSlotAdicional(ArrayList<ArrayList<String>> funcionarios, 
				int startime,
				DateTime etiquetadoday,
				int etiquetadoindex) {
		
		
			ArrayList<String> personalname = new ArrayList<String>();
			personalname.addAll(etiquetado.get(etiquetadoday.getDayOfWeek()).get(etiquetadoindex).personalname);
		
			ArrayList<String> personalid = new ArrayList<String>();
			personalid.addAll(etiquetado.get(etiquetadoday.getDayOfWeek()).get(etiquetadoindex).personalid);
		
			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}
		
			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}
		
			Slot previousslot = etiquetado.get(etiquetadoday.getDayOfWeek()).get(etiquetadoindex);
			Slot previousdayslot = null;
			if(etiquetado.get(etiquetadoday.plusDays(1).getDayOfWeek())!=null) {
				 previousdayslot = etiquetado.get(etiquetadoday.plusDays(1).getDayOfWeek()).get(0);
			}
			// TODO check this routines (time falta seems to be getting only remaining time in this day and next. what about if etiquetado takes more than 2 days?
			// this same check applies for bandas and empaque
			
			int timefalta = 0;
			
			if(previousdayslot!=null) {
				timefalta = previousdayslot.endtime + (previousslot.endtime - currtime);
			}
			else {
				timefalta = previousslot.endtime - currtime;
			}
		
			//int funcionariosize = previousslot.personalid.size();
		
			float newunidades = ( unidades*(((float) timefalta/(duracionetiquetado+timefalta))));
			
			
			int slotunidades = (int) newunidades;
			int unidadesanteriores = unidades-slotunidades;
			
			float duracion = newunidades/db.retrieveProductoDuracionEtiquetado(unidades, productid);
		
			int minimofuncionarios = 2;
		
			duracion = duracion * ((float) minimofuncionarios / personalname.size());
		
			duraciontotaletiquetado = duracion;
		
			duracion = (duracion - ((float) (duracionetiquetado * .1)));
		
			int endtime = (startime + ((int) (duracion * 10))) - 1;
		
			int addday = 0;
		
			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}
		
			if(etiquetadoday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = etiquetadoday.getDayOfWeek() +addday - planday.getDayOfWeek() + 5;
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}
			
			if(addday==0 && endtime > currtime+1 || addday > 0) {
		
				int dayindex = etiquetadoday.plusDays(1).getDayOfWeek();
			
				while(dayindex <= planday.plusDays(5).getDayOfWeek()) {
					if(etiquetado.get(dayindex)!=null)
						etiquetado.remove(dayindex);
					dayindex++;
			
				}
			
				if(currtime != 0 && etiquetado.get(etiquetadoday.getDayOfWeek()).get(etiquetadoindex).starttime != currtime-2 ) {
					etiquetado.get(etiquetadoday.getDayOfWeek()).get(etiquetadoindex).endtime = currtime-1;
					etindex[etiquetadoday.getDayOfWeek()-1]++;
				}
				else {
					etiquetado.get(etiquetadoday.getDayOfWeek()).remove(etiquetadoindex);
				}
				
				
				ArrayList<Slot> slotlist = new ArrayList<Slot>();
			
				if (addday == 0) {
			
					etiquetado.get(etiquetadoday.getDayOfWeek()).add(new Slot(etiquetadoday.getDayOfWeek(), year, month,
							startime, endtime, personalid, personalname, 5, true,
							unidadesanteriores,slotunidades,0));
			
				} else if (addday == 1) {
			
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					int secondunidades = slotunidades - firstunidades;
					
					etiquetado.get(etiquetadoday.getDayOfWeek()).add(new Slot(etiquetadoday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 5, false,
							unidadesanteriores,firstunidades,secondunidades));
			
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(etiquetadoday.plusDays(1).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 5, true,
							firstunidades,secondunidades,0));
			
					etiquetado.put(etiquetadoday.plusDays(1).getDayOfWeek(), slotlist);
				} else if (addday > 1) {
					
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));

					etiquetado.get(etiquetadoday.getDayOfWeek()).add(new Slot(etiquetadoday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 5, false,
							unidadesanteriores,firstunidades,slotunidades-firstunidades));
			
					int anteriores = firstunidades;
					
					for (int i = 1; i < addday; i++) {
						int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
						
						slotlist = new ArrayList<Slot>();
						slotlist.add(new Slot(etiquetadoday.plusDays(i).getDayOfWeek(), year, month,
								0, 99, personalid, personalname, 5, false,
								anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades)));
			
						etiquetado.put(etiquetadoday.plusDays(i).getDayOfWeek(), slotlist);
						
						anteriores += siguientesunidades;
					}
			
					int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));
					
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(etiquetadoday.plusDays(addday).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 5, true,
							anteriores,siguientesunidades,0));
			
					etiquetado.put(etiquetadoday.plusDays(addday).getDayOfWeek(), slotlist);
				}
		
				ArrayList<Integer> var = new ArrayList<Integer>();
				var.add(endtime);
				var.add(addday);
				var.add(1);
				return var;
			}
			else {
				ArrayList<Integer> var = new ArrayList<Integer>();
				var.add(etiquetado.get(etiquetadoday.getDayOfWeek()).get(etiquetadoindex).endtime);
				var.add(addday);
				var.add(0);
				return var;
			}
			
		}

		private ArrayList<Integer> setupBandaSlotAdicional(ArrayList<ArrayList<String>> funcionarios, 
				int startime,
				DateTime bandasday,
				int bandasindex) {


			ArrayList<String> personalname = new ArrayList<String>();
			personalname.addAll(bandas.get(bandasday.getDayOfWeek()).get(bandasindex).personalname);

			ArrayList<String> personalid = new ArrayList<String>();
			personalid.addAll(bandas.get(bandasday.getDayOfWeek()).get(bandasindex).personalid);

			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}

			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}

			Slot previousslot = bandas.get(bandasday.getDayOfWeek()).get(bandasindex);
			Slot previousdayslot = null;
			if(bandas.get(bandasday.plusDays(1).getDayOfWeek())!=null) {
				 previousdayslot = bandas.get(bandasday.plusDays(1).getDayOfWeek()).get(0);
			}
			
			int timefalta = 0;
			
			if(previousdayslot!=null) {
				timefalta = previousdayslot.endtime + (previousslot.endtime - currtime);
			}
			else {
				timefalta = previousslot.endtime - currtime;
			}

			//int funcionariosize = previousslot.personalid.size();
			
			float newunidades = ( unidades*(((float) timefalta/(duracionbandas+timefalta))));
			
			int slotunidades = (int) newunidades;
			int unidadesanteriores = unidades-slotunidades;
			
			float duracion = newunidades/db.retrieveProductoDuracionBandas(unidades, productid);

			int minimofuncionarios = 2;

			duracion = duracion * ((float) minimofuncionarios / personalname.size());

			duraciontotalbandas = duracion;

			duracion = (duracion - ((float) (duracionbandas * .1)));

			int endtime = (startime + ((int) (duracion * 10))) - 1;

			int addday = 0;

			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}

			if(bandasday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = bandasday.getDayOfWeek() +addday - planday.getDayOfWeek() + 5;
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}

			if(addday==0 && endtime > currtime+1 || addday > 0) {
				
				int dayindex = bandasday.plusDays(1).getDayOfWeek();
			
				while(dayindex <= planday.plusDays(5).getDayOfWeek()) {
					if(bandas.get(dayindex)!=null)
						bandas.remove(dayindex);
					dayindex++;
			
				}
			
				if(currtime != 0 && bandas.get(bandasday.getDayOfWeek()).get(bandasindex).starttime != currtime-2 ) {
					bandas.get(bandasday.getDayOfWeek()).get(bandasindex).endtime = currtime-1;
					banindex[bandasday.getDayOfWeek()-1]++;
				}
				else {
					bandas.get(bandasday.getDayOfWeek()).remove(bandasindex);
				}
				
				
				ArrayList<Slot> slotlist = new ArrayList<Slot>();
			
				if (addday == 0) {
			
					bandas.get(bandasday.getDayOfWeek()).add(new Slot(bandasday.getDayOfWeek(), year, month,
							startime, endtime, personalid, personalname, 6, true,
							unidadesanteriores,slotunidades,0));
			
				} else if (addday == 1) {
			
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					int secondunidades = slotunidades - firstunidades;
					
					bandas.get(bandasday.getDayOfWeek()).add(new Slot(bandasday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 6, false,
							unidadesanteriores,firstunidades,secondunidades));
			
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(bandasday.plusDays(1).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 6, true,
							firstunidades,secondunidades,0));
			
					bandas.put(bandasday.plusDays(1).getDayOfWeek(), slotlist);
				} else if (addday > 1) {
					
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));

					bandas.get(bandasday.getDayOfWeek()).add(new Slot(bandasday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 6, false,
							unidadesanteriores,firstunidades,slotunidades-firstunidades));
			
					int anteriores = firstunidades;
					
					for (int i = 1; i < addday; i++) {
						int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
						
						slotlist = new ArrayList<Slot>();
						slotlist.add(new Slot(bandasday.plusDays(i).getDayOfWeek(), year, month,
								0, 99, personalid, personalname, 6, false,
								anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades)));
			
						bandas.put(bandasday.plusDays(i).getDayOfWeek(), slotlist);
						
						anteriores += siguientesunidades;
					}
			
					int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));
					
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(bandasday.plusDays(addday).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 6, true,
							anteriores,siguientesunidades,0));
			
					bandas.put(bandasday.plusDays(addday).getDayOfWeek(), slotlist);
				}
		
				ArrayList<Integer> var = new ArrayList<Integer>();
				var.add(endtime);
				var.add(addday);
				var.add(1);
				return var;
			}
			else {
				ArrayList<Integer> var = new ArrayList<Integer>();
				var.add(endtime);
				var.add(addday);
				var.add(0);
				return var;
			}
		}

		private ArrayList<Integer> setupEmpaqueSlotAdicional(ArrayList<ArrayList<String>> funcionarios, 
				int startime,
				DateTime empaqueday,
				int empaqueindex) {

			ArrayList<String> personalname = new ArrayList<String>();
			personalname.addAll(empaque.get(empaqueday.getDayOfWeek()).get(empaqueindex).personalname);

			ArrayList<String> personalid = new ArrayList<String>();
			personalid.addAll(empaque.get(empaqueday.getDayOfWeek()).get(empaqueindex).personalid);

			for (int i = 0; i < funcionarios.size(); i++) {
				personalname.add(funcionarios.get(i).get(2) + ","
						+ funcionarios.get(i).get(3));
			}

			for (int i = 0; i < funcionarios.size(); i++) {
				personalid.add(funcionarios.get(i).get(0));
			}

			Slot previousslot = empaque.get(empaqueday.getDayOfWeek()).get(empaqueindex);
			Slot previousdayslot = null;
			if(empaque.get(empaqueday.plusDays(1))!=null) {
				 previousdayslot = empaque.get(empaqueday.plusDays(1)).get(0);
			}

			//int funcionariosize = previousslot.personalid.size();

			int timefalta = 0;
			
			if(previousdayslot!=null) {
				timefalta = previousdayslot.endtime + (previousslot.endtime - currtime);
			}
			else {
				timefalta = previousslot.endtime - currtime;
			}
			
			float newunidades = ( unidades*(((float) timefalta/(duracionempaque+timefalta))));
			
			int slotunidades = (int) newunidades;
			int unidadesanteriores = unidades-slotunidades;
		
			float duracion = newunidades/db.retrieveProductoDuracionEmpaque(unidades, productid);
			
			int minimofuncionarios = 2;
			
			duracion = duracion * ((float) minimofuncionarios / personalname.size());
			
			duraciontotalempaque = duracion;
			
			int endtime = (startime + ((int) (duracion * 10))) - 1;
			
			int addday = 0;

			if ((endtime + 1) > 99) {
				addday = endtime / 100;
				endtime = endtime % 100;
			}

			if(empaqueday.getDayOfWeek() +addday >= planday.getDayOfWeek() + 5) {

				int changedays = empaqueday.getDayOfWeek() +addday - planday.getDayOfWeek() + 5;
				addday = addday - changedays;
				@SuppressWarnings("unused")
				int residual = endtime - 49;
				//if(endtime > 49) {
					endtime = 49;
				//}

			}

			if(addday==0 && endtime > currtime+1 || addday > 0) {
				
				int dayindex = empaqueday.plusDays(1).getDayOfWeek();
			
				while(dayindex <= planday.plusDays(5).getDayOfWeek()) {
					if(empaque.get(dayindex)!=null)
						empaque.remove(dayindex);
					dayindex++;
			
				}
			
				if(currtime != 0 && empaque.get(empaqueday.getDayOfWeek()).get(empaqueindex).starttime != currtime-2 ) {
					empaque.get(empaqueday.getDayOfWeek()).get(empaqueindex).endtime = currtime-1;
					empindex[empaqueday.getDayOfWeek()-1]++;
				}
				else {
					empaque.get(empaqueday.getDayOfWeek()).remove(empaqueindex);
				}
				
				
				ArrayList<Slot> slotlist = new ArrayList<Slot>();
			
				if (addday == 0) {
			
					empaque.get(empaqueday.getDayOfWeek()).add(new Slot(empaqueday.getDayOfWeek(), year, month,
							startime, endtime, personalid, personalname, 7, true,
							unidadesanteriores,slotunidades,0));
			
				} else if (addday == 1) {
			
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));
					int secondunidades = slotunidades - firstunidades;
					
					empaque.get(empaqueday.getDayOfWeek()).add(new Slot(empaqueday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 7, false,
							unidadesanteriores,firstunidades,secondunidades));
			
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(empaqueday.plusDays(1).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 7, true,
							firstunidades,secondunidades,0));
			
					empaque.put(empaqueday.plusDays(1).getDayOfWeek(), slotlist);
				} else if (addday > 1) {
					
					int firstunidades =  (int) (slotunidades*(100-startime)/(duracion * 10));

					empaque.get(empaqueday.getDayOfWeek()).add(new Slot(empaqueday.getDayOfWeek(), year, month,
							startime, 99, personalid, personalname, 7, false,
							unidadesanteriores,firstunidades,slotunidades-firstunidades));
			
					int anteriores = firstunidades;
					
					for (int i = 1; i < addday; i++) {
						int siguientesunidades = (int) (slotunidades*(100)/(duracion * 10));
						
						slotlist = new ArrayList<Slot>();
						slotlist.add(new Slot(empaqueday.plusDays(i).getDayOfWeek(), year, month,
								0, 99, personalid, personalname, 7, false,
								anteriores,siguientesunidades,slotunidades-(anteriores+siguientesunidades)));
			
						empaque.put(empaqueday.plusDays(i).getDayOfWeek(), slotlist);
						
						anteriores += siguientesunidades;
					}
			
					int siguientesunidades = (int) (slotunidades*(endtime)/(duracion * 10));
					
					slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(empaqueday.plusDays(addday).getDayOfWeek(), year, month,
							0, endtime, personalid, personalname, 7, true,
							anteriores,siguientesunidades,0));
			
					empaque.put(empaqueday.plusDays(addday).getDayOfWeek(), slotlist);
				}
		
				ArrayList<Integer> var = new ArrayList<Integer>();
				var.add(endtime);
				var.add(addday);
				var.add(1);
				return var;
			}
			else {
				ArrayList<Integer> var = new ArrayList<Integer>();
				var.add(endtime);
				var.add(addday);
				var.add(0);
				return var;
			}
		}

		private String retrieveFaseName(int fase) {

			if (fase == 1) {
				return "Dispensacion";
			} else if (fase == 2) {
				return "Produccion";
			} else if (fase == 3) {
				return "Llenado";
			} else if (fase == 4) {
				return "Loteado";
			} else if (fase == 5) {
				return "Etiquetado";
			} else if (fase == 6) {
				return "Bandas";
			} else if (fase == 7) {
				return "Empacado";
			}

			return null;
		}

		public int retrieveFaseStart(int fase, int day, int index, boolean printing) {

			if (fase == 1) {
				if(dispensacion.size()!=0){
				if(dispensacion.get(0).slotday == day) {
					if(dispensacion.get(0).starttime>=49 && printing)
						return dispensacion.get(0).starttime+10;
					else
						return dispensacion.get(0).starttime;
				}
				else return -1;
				}
				else return -1;
			} else if (fase == 2) {
				if(produccion.size()!=0){
				if(produccion.get(0).slotday == day) {
					if(produccion.get(0).starttime>=49 && printing)
						return produccion.get(0).starttime+10;
					else
						return produccion.get(0).starttime;
				}
				else return -1;
				}
				else return -1;
			} else if (fase == 3) {
				if(llenado.get(day) != null) {
					if(llenado.get(day).starttime>=49 && printing)
						return llenado.get(day).starttime+10;
					else
						return llenado.get(day).starttime;
				}
				else return -1;
			} else if (fase == 4) {
				if(loteado.get(day) != null) {
					if(loteado.get(day).starttime>=49 && printing)
						return loteado.get(day).starttime+10;
					else
						return loteado.get(day).starttime;
				}
				else return -1;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					if(etiquetado.get(day).get(index)!=null) {
						if(etiquetado.get(day).get(index).starttime>=49 && printing)
							return etiquetado.get(day).get(index).starttime+10;
						else
							return etiquetado.get(day).get(index).starttime;
					}
				}
				else return -1;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					if(bandas.get(day).get(index)!=null) {
						if(bandas.get(day).get(index).starttime>=49 && printing)
							return bandas.get(day).get(index).starttime+10;
						else
							return bandas.get(day).get(index).starttime;
					}
				}
				else return -1;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					if(empaque.get(day).get(index)!=null) {
						if(empaque.get(day).get(index).starttime>=49 && printing)
							return empaque.get(day).get(index).starttime+10;
						else
							return empaque.get(day).get(index).starttime;
					}
				}
				else return -1;
			}

			return -1;
		}

		private int retrieveFaseSize(int fase, int day) {

			if (fase == 1) {
				if(dispensacion.get(0).slotday == day)
					return 1;
				else return 0;
			} else if (fase == 2) {
				if(produccion.get(0).slotday == day)
					return 1;
				else return 0;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return 1;
				else return 0;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return 1;
				else return 0;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					return etiquetado.get(day).size();
				}
				else return 0;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					return bandas.get(day).size();
				}
				else return 0;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					return empaque.get(day).size();
				}
				else return 0;
			}

			return 0;
		}

		public int retrieveFaseEnd(int fase, int day, int index, boolean printing) {

			if (fase == 1) {
				if(dispensacion.size()!=0){
				if(dispensacion.get(0).slotday == day) {
					if(dispensacion.get(0).endtime>=50 && printing)
						return dispensacion.get(0).endtime+10;
					else
						return dispensacion.get(0).endtime;
				}
				else return -1;
				}
				else return -1;
			} else if (fase == 2) {
				if(produccion.size()!=0){
				if(produccion.get(0).slotday == day) {
					if(produccion.get(0).endtime>=50 && printing)
						return produccion.get(0).endtime+10;
					else
						return produccion.get(0).endtime;
				}
				else return -1;
				}
				else return -1;
			} else if (fase == 3) {
				if(llenado.get(day) != null) {
					if(llenado.get(day).endtime>=50 && printing)
						return llenado.get(day).endtime+10;
					else
						return llenado.get(day).endtime;
				}
				else return -1;
			} else if (fase == 4) {
				if(loteado.get(day) != null) {
					if(loteado.get(day).endtime>=50 && printing)
						return loteado.get(day).endtime+10;
					else
						return loteado.get(day).endtime;
				}
				else return -1;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					if(etiquetado.get(day).get(index)!=null) {
						if(etiquetado.get(day).get(index).endtime>=50 && printing)
							return etiquetado.get(day).get(index).endtime+10;
						else
							return etiquetado.get(day).get(index).endtime;
					}
				}
				else return -1;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					if(bandas.get(day).get(index)!=null) {
						if(bandas.get(day).get(index).endtime>=50 && printing)
							return bandas.get(day).get(index).endtime+10;
						else
							return bandas.get(day).get(index).endtime;
					}
				}
				else return -1;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					if(empaque.get(day).get(index)!=null) {
						if(empaque.get(day).get(index).endtime>=50 && printing)
							return empaque.get(day).get(index).endtime+10;
						else
							return empaque.get(day).get(index).endtime;
					}
				}
				else return -1;
			}

			return -1;
		}

		
		public ArrayList<String> retrieveFasePersonal(int fase, int day, int index) {

			if (fase == 1) {
				return dispensacion.get(0).personalid;
			} else if (fase == 2) {
				return produccion.get(0).personalid;
			} else if (fase == 3) {
				return llenado.get(day).personalid;
			} else if (fase == 4) {
				return loteado.get(day).personalid;
			} else if (fase == 5) {
				return etiquetado.get(day).get(index).personalid;
			} else if (fase == 6) {
				return bandas.get(day).get(index).personalid;
			} else if (fase == 7) {
				return empaque.get(day).get(index).personalid;
			}

			return null;
		}

		private ArrayList<String> retrieveFasePersonalName(int fase, int day, int index) {

			if (fase == 1) {
				return dispensacion.get(0).personalname;
			} else if (fase == 2) {
				return produccion.get(0).personalname;
			} else if (fase == 3) {
				return llenado.get(day).personalname;
			} else if (fase == 4) {
				return loteado.get(day).personalname;
			} else if (fase == 5) {
				return etiquetado.get(day).get(index).personalname;
			} else if (fase == 6) {
				return bandas.get(day).get(index).personalname;
			} else if (fase == 7) {
				return empaque.get(day).get(index).personalname;
			}

			return null;
		}

		public String retrieveFaseMaquinaria(int fase, int day, int index) {

			if (fase == 1) {
				if(dispensacion.size()!=0){
					if(dispensacion.get(0).slotday == day)
						return dispensacion.get(0).maquinariaid;
					else return null;
				}
				else return null;
			} else if (fase == 2) {
				if(produccion.size()!=0){
					if(produccion.get(0).slotday == day)
						return produccion.get(0).maquinariaid;
					else return null;
				}
				else return null;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return llenado.get(day).maquinariaid;
				else return null;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return loteado.get(day).maquinariaid;
				else return null;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					if(etiquetado.get(day).get(index)!=null)
						return etiquetado.get(day).get(index).maquinariaid;
					else return null;
				}
				else return null;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					if(bandas.get(day).get(index)!=null)
						return bandas.get(day).get(index).maquinariaid;
					else return null;
				}
				else return null;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					if(empaque.get(day).get(index)!=null)
						return empaque.get(day).get(index).maquinariaid;
					else return null;
				}
				else return null;
			}

			return null;
		}

		private String retrieveFaseData(int fase, int day, int index) {
			if (fase == 1) {
				try {
				String str = "<b> Dispensar</b>";
				String funcionarios = "<p> Funcionarios: "
				+ dispensacion.get(0).personalname.get(0) + " | "
				+ dispensacion.get(0).personalname.get(1);
				}
				catch(java.lang.IndexOutOfBoundsException e) {
				//System.out.println("damelo");
				}
				String str = "<b> Dispensar</b>";
				String funcionarios = "<p> Funcionarios: "
				+ dispensacion.get(0).personalname.get(0) + " | "
				+ dispensacion.get(0).personalname.get(1);
				String original = str+funcionarios;
				
				int cut = 0;
				int length = dispensacion.get(0).endtime - dispensacion.get(0).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				return str+funcionarios+";"+cut+";"+original;
			} else if (fase == 2) {
				String str = "<b> Produccion</b>";
				String maquinaria ="<p> Maquina: "
				+ produccion.get(0).maquinarianame;
				String funcionarios ="<p> Funcionarios: "
				+ produccion.get(0).personalname.get(0) + " | "
				+ produccion.get(0).personalname.get(1);
				
				String original = str+maquinaria+funcionarios;
				
				int cut = 0;
				int length = produccion.get(0).endtime - produccion.get(0).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				if(maquinaria.length() - (length*12-3) > 0) {
					cut = 1;
					maquinaria = maquinaria.substring(0, length*12-3);
					maquinaria = maquinaria + "...";
				}
				
				return str+maquinaria+funcionarios+";"+cut+";"+original;
				
			} else if (fase == 3) {
				String str = "<b> Llenado</b>";
				String maquinaria ="<p> Maquina: "
					+ llenado.get(day).maquinarianame;
				String funcionarios = "<p> Funcionarios: ";
				for (int i = 0; i < llenado.get(day).personalname.size(); i++) {
					funcionarios += llenado.get(day).personalname.get(i) + " | ";
				}
				funcionarios = funcionarios.substring(0, funcionarios.length()-3);
				
				String original = str+maquinaria+funcionarios;
				
				int cut = 0;
				int length = llenado.get(day).endtime - llenado.get(day).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				if(maquinaria.length() - (length*12-3) > 0) {
					cut = 1;
					maquinaria = maquinaria.substring(0, length*12-3);
					maquinaria = maquinaria + "...";
				}
				
				return str+maquinaria+funcionarios+";"+cut+";"+original;
			} else if (fase == 4) {
				String str = "<b> Loteado</b>";
				String maquinaria ="<p> Maquina: "
					+ loteado.get(day).maquinarianame;
				String funcionarios = "<p> Funcionarios: ";
				for (int i = 0; i < loteado.get(day).personalname.size(); i++) {
					funcionarios += loteado.get(day).personalname.get(i) + " | ";
				}
				funcionarios = funcionarios.substring(0, funcionarios.length()-3);
				
				String original = str+maquinaria+funcionarios;
				
				int cut = 0;
				int length = loteado.get(day).endtime - loteado.get(day).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				if(maquinaria.length() - (length*12-3) > 0) {
					cut = 1;
					maquinaria = maquinaria.substring(0, length*12-3);
					maquinaria = maquinaria + "...";
				}
				
				return str+maquinaria+funcionarios+";"+cut+";"+original;
			} else if (fase == 5) {
				String str = "<b> Etiquetado</b>";
				String funcionarios = "<p> Funcionarios: ";
				for (int i = 0; i < etiquetado.get(day).get(index).personalname.size(); i++) {
					funcionarios += etiquetado.get(day).get(index).personalname.get(i) + " | ";
				}
				funcionarios = funcionarios.substring(0, funcionarios.length()-3);
				
				String original = str+funcionarios;
				
				int cut = 0;
				int length = etiquetado.get(day).get(index).endtime - etiquetado.get(day).get(index).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				return str+funcionarios+";"+cut+";"+original;
			} else if (fase == 6) {
				String str = "<b> Bandas</b>";
				String funcionarios = "<p> Funcionarios: ";
				for (int i = 0; i < bandas.get(day).get(index).personalname.size(); i++) {
					funcionarios += bandas.get(day).get(index).personalname.get(i) + " | ";
				}
				funcionarios = funcionarios.substring(0, funcionarios.length()-3);
				
				String original = str+funcionarios;
				
				int cut = 0;
				int length = bandas.get(day).get(index).endtime - bandas.get(day).get(index).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				return str+funcionarios+";"+cut+";"+original;
			} else if (fase == 7) {
				String str = "<b> Empaque</b>";
				String funcionarios = "<p> Funcionarios: ";
				for (int i = 0; i < empaque.get(day).get(index).personalname.size(); i++) {
					funcionarios += empaque.get(day).get(index).personalname.get(i) + " | ";
				}
				funcionarios = funcionarios.substring(0, funcionarios.length()-3);
				
				String original = str+funcionarios;
				
				int cut = 0;
				int length = empaque.get(day).get(index).endtime - empaque.get(day).get(index).starttime + 1;
				
				if(funcionarios.length() - (length*12-3) > 0) {
					cut = 1;
					funcionarios = funcionarios.substring(0, length*12-3);
					funcionarios = funcionarios + "...";
				}
				
				return str+funcionarios+";"+cut+";"+original;
			} else {
				return "ERROR DE ASIGNACION DE FASE - REVISAR ALGORITMO";
			}
		}

		private String retrieveLoteData() {
			return "<b> Lote</b>: " + loteid + " <p>" + "  Producto: "
			+ productname + " <p> Unidades: " + unidades + ((this.startingfase > 1)?(";2;200"):(""));
		}
		
		

		private ArrayList<String> freeFuncionarios(int day, int time) {

			
			//int [] currfase = currentFase(day);
			int currfase[] = new int[2];
			currfase[0] = currentfase;
			//System.out.println("loteid = " + loteid + ":currfase = " + currfase[0]);

			if(currfase[0] == 5) {
				currfase[1] = etindex[day-1];
			}
			else if(currfase[0] == 6) {
				currfase[1] = banindex[day-1];
			}
			else if(currfase[0] == 7) {
				
				currfase[1] = empindex[day-1];
			}
			else {
				currfase[1] = -1;
			}

			
			if (currfase[0] != 0) {
				//System.out.println("fase end = " + retrieveFaseEnd(currfase[0], day, currfase[1],false));
				if (retrieveFaseEnd(currfase[0], day, currfase[1],false) == time) {
					//System.out.println("currfase = " + currfase[0] + " funcionario is going to be free = " 
					//		+ retrieveFasePersonal(currfase[0], day, currfase[1]));
					////System.out.println("funcionario is going to be free");
					return retrieveFasePersonal(currfase[0], day, currfase[1]);

				} else
					return null;
			} else
				return null;
		}

		private String freeMaquinaria(int day, int time) {

			//int [] currfase = currentFase(day);
			int currfase[] = new int[2];
			currfase[0] = currentfase;
			if(currfase[0] == 5) {
				currfase[1] = etindex[day-planday.getDayOfWeek()];
			}
			else if(currfase[0] == 6) {
				currfase[1] = banindex[day-planday.getDayOfWeek()];
			}
			else if(currfase[0] == 7) {
				currfase[1] = empindex[day-planday.getDayOfWeek()];
			}
			else {
				currfase[1] = -1;
			}

			if (currfase[0] != 0) {
				if (retrieveFaseEnd(currfase[0], day, currfase[1],false) == time) {
					////System.out.println("maquinaria is going to be free");
					////System.out.println("maquinaria is going to be free "
					//		+ currfase[0] + "--" + retrieveFaseMaquinaria(currfase[0], day, currfase[1]));

					return retrieveFaseMaquinaria(currfase[0], day, currfase[1]);

				} else
					return null;
			} else
				return null;
		}

		@SuppressWarnings("unused")
		private int[] currentFase(int day) {

			if ((dispensacion.size() > 0 && dispensacion.get(0).slotday == day)
					&& currtime >= dispensacion.get(0).starttime
					&& dispensacion.get(0).endtime >= currtime) {
				//System.out.println("loteid = " + loteid + "currfase check for dispensacion");
				return new int[] {1,-1};

			} if ((produccion.size() > 0 && produccion.get(0).slotday == day)
					&& currtime >= produccion.get(0).starttime
					&& produccion.get(0).endtime >= currtime) {
				//System.out.println("loteid = " + loteid + "currfase check for produccion");
				return new int[] {2,-1};
			} if ((llenado.size() > 0 && llenado.get(day) != null)
					&& currtime >= llenado.get(day).starttime
					&& llenado.get(day).endtime >= currtime) {
				return new int[] {3,-1};
			} if ((loteado.size() > 0 && loteado.get(day) != null)
					&& currtime >= loteado.get(day).starttime
					&& loteado.get(day).endtime >= currtime) {
				//System.out.println("loteid = " + loteid + "currfase check for loteado");
				return new int[] {4,-1};
			} if (etiquetado.size() > 0 && etiquetado.get(day) != null) {
				for(int i =0; i < etiquetado.get(day).size(); i++) {	
					if(currtime >= etiquetado.get(day).get(i).starttime
							&& etiquetado.get(day).get(i).endtime >= currtime) {
						//System.out.println("loteid = " + loteid + " i: " + i + "currfase check for etiquetado");
						return new int[] {5,i};
					}
				}
			} 
			if (bandas.size() > 0 && bandas.get(day) != null) {
				for(int i =0; i < bandas.get(day).size(); i++) {	
					if(currtime >= bandas.get(day).get(i).starttime
							&& bandas.get(day).get(i).endtime >= currtime) {
						//System.out.println("loteid = " + loteid + "i:" + i + "currfase check for bandas");
						return new int[] {6,i};
					}
				}
			} 
			if (empaque.size() > 0 && empaque.get(day) != null) {
				for(int i =0; i < empaque.get(day).size(); i++) {	
					if(currtime >= empaque.get(day).get(i).starttime
							&& empaque.get(day).get(i).endtime >= currtime) {
						//System.out.println("loteid = " + loteid + "i:" + i + "currfase check for empaque");
						return new int[] {7,i};
						
					}
				}
			} 

			return new int[] {0,-1};

		}

		public int confirmLote(int status) {
			this.loteid = db.insertLote(lotehora,loteday,planday.getDayOfMonth(), month, year, produccionid,
					productid, productname, unidades,litros,status,done,donedia,startingfase);
			
			return this.loteid;
		}
		
		public int confirmLote(int status,int loteid,int planday) {
			db.insertLote(lotehora,loteday,planday, month, year, produccionid,
					productid, productname, unidades,litros,status,done,donedia,startingfase,loteid);
			this.loteid = loteid;
			
			return this.loteid;
		}
		
		public void changeLoteDay(int day) {
			Database db = new Database();
			
			db.modifyLoteDay(loteid, planday.getDayOfMonth(), day);
			
			db.closeConnection();
		}
		
		public void changeLoteHour(int hour) {
			Database db = new Database();
			
			db.modifyLoteHour(loteid, planday.getDayOfMonth(), hour);
			
			db.closeConnection();
		}
		
		public void confirmLoteReal(int status) {
			Database db = new Database();
			
			db.insertLote(lotehora,loteday,planday.getDayOfMonth(), month, year, produccionid,
					productid, productname, unidades,litros,status,done,donedia,startingfase,loteid);
			
			db.closeConnection();
		}
		
		/*public int confirmLoteReal() {
			int id = db.confirmLoteReal(loteid);
			
			return id;
		}*/

		@SuppressWarnings("unused")
		private void setLoteId(int loteid) {
			this.loteid = loteid;
		}

		public void confirmSlot(int fase, boolean proyectadooreal) {
			if (fase == 1 && dispensacion.size()!=0) {
				dispensacion.get(0).confirmSlot(loteid,proyectadooreal);
				//System.out.println("dispensacion slot confirmed");
			} else if (fase == 2 && produccion.size() != 0) {
				produccion.get(0).confirmSlot(loteid,proyectadooreal);
				//System.out.println("produccion slot confirmed");
			} else if (fase == 3) {
				Iterator<Entry<Integer,Planner.Slot>> it = llenado.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry<Integer,Planner.Slot> pairs = (Map.Entry<Integer,Planner.Slot>) it.next();
					llenado.get(pairs.getKey()).confirmSlot(loteid,proyectadooreal);
					// pairs.getKey() + " = " + pairs.getValue());
				}
				// llenado.get(day).confirmSlot(loteid);
				//System.out.println("llenado slot confirmed");
			} else if (fase == 4) {
				Iterator<Entry<Integer,Planner.Slot>> it = loteado.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry<Integer,Planner.Slot> pairs = (Map.Entry<Integer,Planner.Slot>) it.next();
					loteado.get(pairs.getKey()).confirmSlot(loteid,proyectadooreal);
					// pairs.getKey() + " = " + pairs.getValue());
				}
			} else if (fase == 5) {
				Iterator<Map.Entry<Integer,ArrayList<Planner.Slot>>> it = etiquetado.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry<Integer,ArrayList<Planner.Slot>> pairs = (Map.Entry<Integer,ArrayList<Planner.Slot>>) it.next();
					for(int i=0; i < etiquetado.get(pairs.getKey()).size(); i++) {
						etiquetado.get(pairs.getKey()).get(i).confirmSlot(loteid,proyectadooreal);
					}
					// pairs.getKey() + " = " + pairs.getValue());
				}
			} else if (fase == 6) {
				Iterator<Map.Entry<Integer,ArrayList<Planner.Slot>>> it = bandas.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry<Integer,ArrayList<Planner.Slot>> pairs = (Map.Entry<Integer,ArrayList<Planner.Slot>>) it.next();
					for(int i=0; i < bandas.get(pairs.getKey()).size(); i++) {
						bandas.get(pairs.getKey()).get(i).confirmSlot(loteid,proyectadooreal);
					}
					// pairs.getKey() + " = " + pairs.getValue());
				}
			} else if (fase == 7) {
				Iterator<Map.Entry<Integer,ArrayList<Planner.Slot>>> it = empaque.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry<Integer,ArrayList<Planner.Slot>> pairs = (Map.Entry<Integer,ArrayList<Planner.Slot>>) it.next();
					for(int i=0; i < empaque.get(pairs.getKey()).size(); i++)
						empaque.get(pairs.getKey()).get(i).confirmSlot(loteid,proyectadooreal);
					// pairs.getKey() + " = " + pairs.getValue());
				}
			}
		}
		
		public void confirmDaySlot(int fase, boolean proyectadooreal,int firstday, int lastday) {
			if (fase == 1 && dispensacion.size()!=0) {
				dispensacion.get(0).confirmSlot(loteid,proyectadooreal);
				////System.out.println("dispensacion slot confirmed");
			} else if (fase == 2 && produccion.size() != 0) {
				produccion.get(0).confirmSlot(loteid,proyectadooreal);
				////System.out.println("produccion slot confirmed");
			} else if (fase == 3) {
				for(int i=firstday;i<=lastday;i++) {
					if(llenado.get(i) != null) {
						llenado.get(i).confirmSlot(loteid,proyectadooreal);
					}
				}
			} else if (fase == 4) {
				for(int i=firstday;i<=lastday;i++) {
					if(loteado.get(i) != null) {
						loteado.get(i).confirmSlot(loteid,proyectadooreal);
					}
				}
			} else if (fase == 5) {
				for(int i=firstday;i<=lastday;i++) {
					if(etiquetado.get(i)!= null) {
						
					for(int j=0; j < etiquetado.get(i).size(); j++) {
						if(etiquetado.get(i).get(j) != null) {
							etiquetado.get(i).get(j).confirmSlot(loteid,proyectadooreal);
						}
					}
					}
				}
			} else if (fase == 6) {
				for(int i=firstday;i<=lastday;i++) {
					if(bandas.get(i)!= null) {
					for(int j=0; j < bandas.get(i).size(); j++) {
						if(bandas.get(i).get(j) != null) {
							bandas.get(i).get(j).confirmSlot(loteid,proyectadooreal);
						}
					}
					}
				}
			} else if (fase == 7) {
				for(int i=firstday;i<=lastday;i++) {
					if(empaque.get(i)!= null) {
					for(int j=0; j < empaque.get(i).size(); j++) {
						if(empaque.get(i).get(j) != null) {
							empaque.get(i).get(j).confirmSlot(loteid,proyectadooreal);
						}
					}
					}
				}
			}
		}
		
		public void confirmDaySlotReal(int fase, boolean proyectadooreal,int firstday, int lastday) {
			
			if (fase == 1 && dispensacion.size()!=0) {
				dispensacion.get(0).confirmSlotReal(loteid,proyectadooreal);
				////System.out.println("dispensacion slot confirmed");
			} else if (fase == 2 && produccion.size() != 0) {
				produccion.get(0).confirmSlotReal(loteid,proyectadooreal);
				////System.out.println("produccion slot confirmed");
			} else if (fase == 3) {
				for(int i=firstday;i<=lastday;i++) {
					if(llenado.get(i) != null) {
						llenado.get(i).confirmSlotReal(loteid,proyectadooreal);
					}
				}
			} else if (fase == 4) {
				for(int i=firstday;i<=lastday;i++) {
					if(loteado.get(i) != null) {
						loteado.get(i).confirmSlotReal(loteid,proyectadooreal);
					}
				}
			} else if (fase == 5) {
				for(int i=firstday;i<=lastday;i++) {
					if(etiquetado.get(i)!= null) {
						
					for(int j=0; j < etiquetado.get(i).size(); j++) {
						if(etiquetado.get(i).get(j) != null) {
							etiquetado.get(i).get(j).confirmSlotReal(loteid,proyectadooreal);
						}
					}
					}
				}
			} else if (fase == 6) {
				for(int i=firstday;i<=lastday;i++) {
					if(bandas.get(i)!= null) {
					for(int j=0; j < bandas.get(i).size(); j++) {
						if(bandas.get(i).get(j) != null) {
							bandas.get(i).get(j).confirmSlotReal(loteid,proyectadooreal);
						}
					}
					}
				}
			} else if (fase == 7) {
				for(int i=firstday;i<=lastday;i++) {
					if(empaque.get(i)!= null) {
					for(int j=0; j < empaque.get(i).size(); j++) {
						if(empaque.get(i).get(j) != null) {
							empaque.get(i).get(j).confirmSlotReal(loteid,proyectadooreal);
						}
					}
					}
				}
			}
		}

		@SuppressWarnings("unused")
		private void setCurrentFase(int fase) {
			nextfase = fase;
		}

		public void addSlot(int day, String year, String month, int starttime, int endtime,
				String maquinariaid, String maquinarianame,
				ArrayList<String> id, ArrayList<String> name,
				int fase, boolean finalizada, int unidadesanteriores, int unidades, int unidadespendientes) {

			if(fase == 1) {
				dispensacion.add(new Slot(day,year,month,starttime,endtime,
						maquinariaid,maquinarianame,
						id,name,
						fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
			}
			else if(fase == 2) {	
				produccion.add(new Slot(day,year,month,starttime,endtime,
						maquinariaid,maquinarianame,
						id,name,
						fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
			}
			else if(fase == 3) {
				llenado.put(day,new Slot(day,year,month,starttime,endtime,
						maquinariaid,maquinarianame,
						id,name,
						fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
			}
			else if(fase == 4) {
				loteado.put(day,new Slot(day,year,month,starttime,endtime,
						maquinariaid,maquinarianame,
						id,name,
						fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
			}
			else if(fase == 5) {
				if(etiquetado.get(day) != null) {
					etiquetado.get(day).add(new Slot(day,year,month,starttime,endtime,
							id,name,
							fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
				}
				else {
					ArrayList<Slot> slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(day,year,month,starttime,endtime,
							id,name,
							fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
					etiquetado.put(day,slotlist);
				}
			}
			else if(fase == 6) {
				if(bandas.get(day) != null) {
					bandas.get(day).add(new Slot(day,year,month,starttime,endtime,
							id,name,
							fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
				}
				else {
					ArrayList<Slot> slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(day,year,month,starttime,endtime,
							id,name,
							fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
					bandas.put(day,slotlist);
				}
			}
			else if(fase == 7) {
				if(empaque.get(day) != null) {
					empaque.get(day).add(new Slot(day,year,month,starttime,endtime,
							id,name,
							fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
				}
				else {
					ArrayList<Slot> slotlist = new ArrayList<Slot>();
					slotlist.add(new Slot(day,year,month,starttime,endtime,
							id,name,
							fase,finalizada,unidadesanteriores,unidades,unidadespendientes));
					empaque.put(day,slotlist);
				}
			}

		}

		private void loteIsDone(int donedia) {
			this.donedia = donedia;
			done = true;
		}

		private boolean isLoteDone() {
			return done;
		}

		public int getLoteID() {
			return loteid;
		}

		public String getproductName() {
			return productname;
		}
		
		public String getproductID() {
			return productid;
		}
		
		public String getmensualID() {
			return produccionid;
		}

		public int getLoteUnidades() {
			return unidades;
		}
		
		public int getLoteLitros() {
			return litros;
		}
		
		public int[] getFases(int day) {
			int[] fases = new int[7];
			for(int i = 1; i< 8; i++) {
				fases[i-1] = retrieveFaseStart(i,day,0,false);
			}
			return fases;
		}
		
		public int lastFaseFinalizada(int day) {
			int lastfase = -1;
			if(day!=planday.getDayOfWeek()) {
				for(int i=day-1; i>=planday.getDayOfWeek(); i--) {
					int[] fases = getFases(i);
					for(int j=fases.length-1; lastfase == -1 && j>=0; j--) {
						if(fases[j]!=-1) {
							if(isFinalizada(i,j+1)) {
								lastfase = j+1;
							}
							else {
								if(j==6)
									lastfase = 7;
								else 
									lastfase = j+2;
							}
							//break;
						}
					}
				}
				return lastfase;
			}
			
			return lastfase;
		}
		
		public int lastFase(int day) {
			int lastfase = -1;
			if(day!=planday.getDayOfWeek()) {
				for(int i=day-1; i>=planday.getDayOfWeek(); i--) {
					
					int[] fases = getFases(i);
					
					for(int j=fases.length-1; lastfase == -1 && j>=0; j--) {
						if(fases[j]!=-1) {
							if(isFinalizada(i,j+1)) {
								this.islastfasefinalizada = true;
								this.lastfase = (j+1);  
								return -(j+1);
							}
							else {
								this.islastfasefinalizada = false;
								this.lastfase = (j+1); 
								return j+1;
							}
							//break;
						}
					}
				}
				return lastfase;
			}
			return lastfase;
		}
		
		public int lastFaseDay(int day) {
			int lastfase = -1;
			if(day!=planday.getDayOfWeek()) {
				int i=0;
				for(i=day-1; i>=planday.getDayOfWeek(); i--) {
					int[] fases = getFases(i);
					for(int j=fases.length-1; lastfase == -1 && j>=0; j--) {
						if(fases[j]!=-1) {
							if(isFinalizada(i,j+1)) {
								return i;
							}
							else {
								return i;
							}
							//break;
						}
					}
				}
				return i;
			}
		
		return planday.getDayOfWeek();
	}
			
			
		
		public boolean isFaseFinalizada(int fase, int day) {
			if (fase == 1) {
				if(produccion.get(0).slotday == day)
					return true;
				else return false;
			} else if (fase == 2) {
				return true;
			} else if (fase == 3) {
				for(int i=day+1; i<= planday.plusDays(5).getDayOfWeek(); i++) {
					if(llenado.get(i) != null)
						return false;
				}
				//TODO insert check to see if it is the last fase in lote and it carries over to next week
				
				//for(int i=day; i<= planday+5; i++) {
				//	if(loteado.get(day) != null)
				//		return true;
				//}
				return true;
			} else if (fase == 4) {
				for(int i=day+1; i<= planday.plusDays(5).getDayOfWeek(); i++) {
					if(loteado.get(i) != null)
						return false;
				}
				//TODO insert check to see if it is the last fase in lote and it carries over to next week
				
				return true;
			} else if (fase == 5) {
				for(int i=day+1; i<= planday.plusDays(5).getDayOfWeek(); i++) {
					if(etiquetado.get(i) != null)
						return false;
				}
				//TODO insert check to see if it is the last fase in lote and it carries over to next week
				
				return true;
			} else if (fase == 6) {
				for(int i=day+1; i<= planday.plusDays(5).getDayOfWeek(); i++) {
					if(bandas.get(i) != null)
						return false;
				}
				//TODO insert check to see if it is the last fase in lote and it carries over to next week
				
				return true;
			} else if (fase == 7) {
				for(int i=day+1; i<= planday.plusDays(5).getDayOfWeek(); i++) {
					if(empaque.get(i) != null)
						return false;
				}
				//TODO insert check to see if it is the last fase in lote and it carries over to next week
				
				return true;
			}
			
			return false;
		}
		
		public boolean isFinalizada(int day, int fase) {
			
			if (fase == 1) {
				if(dispensacion.get(0) != null)
					return dispensacion.get(0).finalizada;
				else return false;
			} else if (fase == 2) {
				if(produccion.get(0) != null)
					return produccion.get(0).finalizada;
				else return false;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return llenado.get(day).finalizada;
				else return false;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return loteado.get(day).finalizada;
				else return false;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					if(etiquetado.get(day).size() != 0) {
						if(etiquetado.get(day).get(etiquetado.get(day).size()-1) != null)
							return etiquetado.get(day).get(etiquetado.get(day).size()-1).finalizada;
						else return false;
					}
					else return false;
				}
				else return false;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					if(bandas.get(day).size() != 0) {
						if(bandas.get(day).get(bandas.get(day).size()-1) != null)
							return bandas.get(day).get(bandas.get(day).size()-1).finalizada;
						else return false;
					} 
					else return false;
				}
				else return false;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					if(empaque.get(day).size() != 0) {
						if(empaque.get(day).get(empaque.get(day).size()-1) != null)
							return empaque.get(day).get(empaque.get(day).size()-1).finalizada;
						else return false;
					}
					else return false;
				}
				else return false;
			}

			return false;
		}
		
		public int getFaseUnidades(int day, int fase) {
			
			if (fase == 1) {
				if(dispensacion.get(0) != null)
					return dispensacion.get(0).unidadesslot;
				else return -1;
			} else if (fase == 2) {
				if(produccion.get(0) != null)
					return produccion.get(0).unidadesslot;
				else return -1;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return llenado.get(day).unidadesslot;
				else return -1;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return loteado.get(day).unidadesslot;
				else return -1;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					if(etiquetado.get(day).size() != 0) {
						if(etiquetado.get(day).get(etiquetado.get(day).size()-1) != null)
							return etiquetado.get(day).get(etiquetado.get(day).size()-1).unidadesslot;
						else return -1;
					}
					else return -1;
				}
				else return -1;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					if(bandas.get(day).size() != 0) {
						if(bandas.get(day).get(bandas.get(day).size()-1) != null)
							return bandas.get(day).get(bandas.get(day).size()-1).unidadesslot;
						else return -1;
					}
					else return -1;
				}
				else return -1;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					if(empaque.get(day).size() != 0) {
						if(empaque.get(day).get(empaque.get(day).size()-1) != null)
							return empaque.get(day).get(empaque.get(day).size()-1).unidadesslot;
						else return -1;
					}
					else return -1;
				}
				else return -1;
			}

			return -1;
		}
		
		public int getFaseUnidadesAnteriores(int day, int fase) {
			
			if (fase == 1) {
				if(dispensacion.get(0) != null)
					return dispensacion.get(0).unidadesanteriores;
				else return -1;
			} else if (fase == 2) {
				if(produccion.get(0) != null)
					return produccion.get(0).unidadesanteriores;
				else return -1;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return llenado.get(day).unidadesanteriores;
				else return -1;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return loteado.get(day).unidadesanteriores;
				else return -1;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					if(etiquetado.get(day).size() != 0) {
						if(etiquetado.get(day).get(etiquetado.get(day).size()-1) != null)
							return etiquetado.get(day).get(etiquetado.get(day).size()-1).unidadesanteriores;
						else return -1;
					}
					else return -1;
				}
				else return -1;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					if(bandas.get(day).size() != 0) {
						if(bandas.get(day).get(bandas.get(day).size()-1) != null)
							return bandas.get(day).get(bandas.get(day).size()-1).unidadesanteriores;
						else return -1;
					}
					else return -1;
				}
				else return -1;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					if(empaque.get(day).size() != 0) {
						if(empaque.get(day).get(empaque.get(day).size()-1) != null)
							return empaque.get(day).get(empaque.get(day).size()-1).unidadesanteriores;
						else return -1;
					}
					else return -1;
				}
				else return -1;
			}

			return -1;
		}
		
		public int getFaseSize(int day, int fase) {
			if (fase == 1) {
				if(dispensacion.get(0).slotday == day)
					return 1;
				else return 0;
			} else if (fase == 2) {
				if(produccion.get(0).slotday == day)
					return 1;
				else return 0;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return 1;
				else return 0;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return 1;
				else return 0;
			} else if (fase == 5) {
				if(etiquetado.get(day) != null) {
					return etiquetado.get(day).size();
				}
				else return 0;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					return bandas.get(day).size();
				}
				else return 0;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					return empaque.get(day).size();
				}
				else return 0;
			}

			return 0;
		}
		
		public Slot getSlot(int day, int fase, int index) {
			if (fase == 1) {
				if(dispensacion.get(0).slotday == day)
					return dispensacion.get(0);
				else return null;
			} else if (fase == 2) {
				if(produccion.get(0).slotday == day)
					return produccion.get(0);
				else return null;
			} else if (fase == 3) {
				if(llenado.get(day) != null)
					return llenado.get(day);
				else return null;
			} else if (fase == 4) {
				if(loteado.get(day) != null)
					return loteado.get(day);
				else return null;
			} 
			if (fase == 5) {
				if(etiquetado.get(day) != null) {
					return etiquetado.get(day).get(index);
				}
				else return null;
			} else if (fase == 6) {
				if(bandas.get(day) != null) {
					return bandas.get(day).get(index);
				}
				else return null;
			} else if (fase == 7) {
				if(empaque.get(day) != null) {
					return empaque.get(day).get(index);
				}
				else return null;
			}
			else {
				return null;
			}
		}
		
		public void initDispensacion(int day) {
			dispensacion.get(0).slotday = day;
		}
		
		public void initProduccion(int day) {
			produccion.get(0).slotday = day;
		}
		
		public void clearSlots(int day, int fase, int index) {
			if (fase == 1) {
					dispensacion.get(0).slotday = -1;
			} else if (fase == 2) {
					produccion.get(0).slotday = -1;
			} else if (fase == 3) {
					llenado.clear();
			} else if (fase == 4) {
					loteado.clear();
			} 
			else if (fase == 5) {
					etiquetado.clear();
			} else if (fase == 6) {
				bandas.clear();
			} else if (fase == 7) {
				empaque.clear();
			}
			else {
			
			}
			
		}
		
		public void setLastFase(int fase) {
			this.lastfase = fase;
		}
		
		public int getLastFase() {
			return lastfase;
		}
		
		
		public HashMap<Integer,Event> generateEvents(int day) {
			
			HashMap<Integer,Event> events = new HashMap<Integer,Event>();
			int fases[] = getFases(day);
			
			for(int i=0; i<7; i++) {
				if(fases[i]!= -1) {
					Event startev = new Event(loteid,i+1,retrieveFaseStart(i+1,day,0,false),retrieveFasePersonal(i+1,day,0),retrieveFaseMaquinaria(i+1,day,0),true);
					Event finev = new Event(loteid,i+1,retrieveFaseEnd(i+1,day,0,false),retrieveFasePersonal(i+1,day,0),retrieveFaseMaquinaria(i+1,day,0),false);
					
					events.put(startev.hora,startev);
					events.put(finev.hora,finev);
				}
			}
			
			return events;
			
		}
		
		public int getNextFase(int currentfase) {
			

			if(currentfase == 2) {
				return 3;
			}
			else if(currentfase == 3 && requiereloteado) {
				return 4;
			}
			else if((currentfase == 3 || currentfase == 4) &&  requiereetiquetado) {
				return 5;
			}
			else if((currentfase == 3 || currentfase == 4 || currentfase == 5) && requierebandas) {
				return 6;
			}
			else if(currentfase >= 3 && currentfase <=6) {
				return 7;
			}
			else {
				return 8;
			}
			
		}
		
		public void modifyStartTimeLote(int lotehora) {
			this.lotehora = lotehora;
		}
		
		public boolean esPosibleBorrarLote(int day) {
			if(loteday < day) {
				return false;
			}
			else if(startingfase != 1)
				return false;
			else 
				return true;
		}
		
		public void modifyPlanDayLote(int day) {
			this.loteday = day;
		}


	}

	public class Slot {
		int unidadesanteriores;
		int unidadesslot;
		int unidadespendientes;
		
		public int slotday;
		String year;
		String month;
		public int starttime;
		public int endtime;
		String maquinariaid;
		String maquinarianame;
		ArrayList<String> personalname;
		ArrayList<String> personalid;
		int fase;
		boolean finalizada;

		Slot(int slotday, String year, String month, int starttime, int endtime,
				String maquinariaid, String maquinarianame,
				ArrayList<String> personalid, ArrayList<String> personalname,
				int fase, boolean finalizada, int unidadesanteriores, int unidadesslot, int unidadespendientes) {
			//super();
			this.personalname = new ArrayList<String>();
			this.personalid = new ArrayList<String>();
			this.slotday = slotday;
			this.year = year;
			this.month = month;
			this.starttime = starttime;
			this.endtime = endtime;
			this.maquinariaid = maquinariaid;
			this.maquinarianame = maquinarianame;
			this.personalname.addAll(personalname);
			this.personalid.addAll(personalid);
			this.fase = fase;
			this.finalizada = finalizada;
			this.unidadesanteriores = unidadesanteriores;
			this.unidadesslot = unidadesslot;
			this.unidadespendientes = unidadespendientes;
		}

		Slot(int slotday, String year, String month, int starttime, int endtime,
				ArrayList<String> personalid, ArrayList<String> personalname,
				int fase, boolean finalizada, int unidadesanteriores, int unidadesslot, int unidadespendientes) {
			//super();
			this.personalname = new ArrayList<String>();
			this.personalid = new ArrayList<String>();
			this.slotday = slotday;
			this.year = year;
			this.month = month;
			this.starttime = starttime;
			this.endtime = endtime;
			this.maquinariaid = null;
			this.maquinarianame = null;
			this.personalname.addAll(personalname);
			this.personalid.addAll(personalid);
			this.fase = fase;
			this.finalizada = finalizada;
			this.unidadesanteriores = unidadesanteriores;
			this.unidadesslot = unidadesslot;
			this.unidadespendientes = unidadespendientes;
		}

		public Slot cloneSlot() {
			try {
				return (Slot) this.clone();
			} catch (CloneNotSupportedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return null;
		}
		
		public void confirmSlot(int loteid, boolean proyectadooreal) {
			db.insertSlot(starttime, endtime, maquinariaid, maquinarianame,
					personalid, personalname, fase, finalizada, slotday,planday.getDayOfMonth(), month, year, loteid,
					proyectadooreal,unidadesanteriores,unidadesslot,unidadespendientes);
		}
		
		public void confirmSlotReal(int loteid, boolean proyectadooreal) {
			Database db = new Database();
			db.insertSlot(starttime, endtime, maquinariaid, maquinarianame,
					personalid, personalname, fase, finalizada, slotday,planday.getDayOfMonth(), month, year, loteid,
					proyectadooreal,unidadesanteriores,unidadesslot,unidadespendientes);
			db.closeConnection();
		}
		
		public void modifyTimes(int starttime, int endtime) {
			this.starttime = starttime;
			this.endtime = endtime;
		}
		
		public void modifyPersonal(ArrayList<String> personalid, ArrayList<String> personalname) {
			this.personalname = new ArrayList<String>();
			this.personalid = new ArrayList<String>();
			this.personalname.addAll(personalname);
			this.personalid.addAll(personalid);
		}
		
		public void modifyMaquinaria(String maquinariaid, String maquinarianame) {
			this.maquinariaid = maquinariaid;
			this.maquinarianame = maquinarianame;
		}
		
		public void modifyFinalizacion(boolean finalizada) {
			this.finalizada = finalizada;
		}
		
		public void modifyUnidades(int unidadesanteriores, int unidadesslot, int unidadespendientes) {
			this.unidadesanteriores = unidadesanteriores;
			this.unidadesslot = unidadesslot;
			this.unidadespendientes = unidadespendientes;
		}
	}

	public Planner(Planner plan) {
		super();
		this.status = plan.status;
		this.currtime = plan.currtime;
		this.dayindex = plan.dayindex;
		this.indicedia = plan.indicedia;
		this.planday = plan.planday;
		this.month = plan.month;
		this.year = plan.year;
		this.lotes = plan.lotes;
		this.loteids = plan.loteids;
		this.nextdaylotes = plan.nextdaylotes;
		this.listOfMensuales = plan.listOfMensuales;
		this.nextloteid = plan.nextloteid;
		this.time = plan.time;
		this.done = plan.done;
		this.exists = plan.exists;
		this.modo = plan.modo;
		this.etiquetadomax = plan.etiquetadomax;
		this.bandasmax = plan.bandasmax;
		this.empacadomax = plan.empacadomax;
		this.copyavaListOfMaquinariaProduccion = plan.copyavaListOfMaquinariaProduccion;
		this.copyavaListOfMaquinariaLlenado = plan.copyavaListOfMaquinariaLlenado;
		this.copyavaListOfMaquinariaLoteado = plan.copyavaListOfMaquinariaLoteado;
		this.avaListOfMaquinariaProduccion = plan.avaListOfMaquinariaProduccion;
		this.avaListOfMaquinariaLlenado = plan.avaListOfMaquinariaLlenado;
		this.avaListOfMaquinariaLoteado = plan.avaListOfMaquinariaLoteado;
		this.currListOfMaquinariaProduccion = plan.currListOfMaquinariaProduccion;
		this.currListOfMaquinariaLlenado = plan.currListOfMaquinariaLlenado;
		this.currListOfMaquinariaLoteado = plan.currListOfMaquinariaLoteado;
		this.copyavaListOfFuncionarios = plan.copyavaListOfFuncionarios;
		this.avaListOfFuncionarios = plan.avaListOfFuncionarios;
		this.currListOfFuncionarios = plan.currListOfFuncionarios;
		this.capacidaddeoperarLlenado = plan.capacidaddeoperarLlenado;
		this.capacidaddeoperarProduccion = plan.capacidaddeoperarProduccion;
		this.capacidaddeoperarLoteado = plan.capacidaddeoperarLoteado;
		this.maquinasPuedenLlenar = plan.maquinasPuedenLlenar;
		this.maquinasPuedenProducir = plan.maquinasPuedenProducir;
		this.maquinasPuedenLotear = plan.maquinasPuedenLotear;
		this.db = plan.db;
		this.ml = plan.ml;
		this.cellAtt = plan.cellAtt;
	}
	
	public Planner(int planday, String month, String year, String modo, int dayindex) {
		super();

		etiquetadomax = 5;
		bandasmax = 6;
		empacadomax = 8;
		//nextloteid = 0;
		this.dayindex = dayindex;
		this.indicedia = 0;


		time = new ArrayList<String>();
		String firsttime = "07:00";
		String endtime = "18:00";

		SimpleDateFormat formatter = new SimpleDateFormat("HH:mm");
		Calendar cal = Calendar.getInstance();
		Calendar endcal = Calendar.getInstance();
		try {
			cal.setTime(formatter.parse(firsttime));
			endcal.setTime(formatter.parse(endtime));
		} catch (ParseException e1) {

			e1.printStackTrace();
		}

		time.add(formatter.format(cal.getTime()));

		while (cal.before(endcal)) {
			cal.add(Calendar.MINUTE, 6);
			time.add(formatter.format(cal.getTime()));
			////System.out.println(formatter.format(cal.getTime()));
		}

		lotes = new HashMap<Integer, Lote>();
		loteids =  new ArrayList<Integer>();
		nextdaylotes = new ArrayList<Lote>();
		this.modo = modo;
		this.month = month;
		this.year = year;
		this.planday = new DateTime(Integer.valueOf(year), Constants.monthsmap.get(month), planday, 0, 0);
		currtime = 0;
		this.dayindex = dayindex + 1;
		done = false;
		exists = false;

		db = new Database();
		
		nextloteid = 0;
		
	}

	public synchronized void run() {

		nextloteid = db.retrieveNextLoteID();
		

		if (modo.equals("actualizar")) {

			//figure out lotes which have pending fases and start with those
			// deprecated funcitionality
		
			

			db.deleteAllLotesFromWeek(planday.getDayOfMonth(),month,year);
			
			lotes = new HashMap<Integer, Lote>( (HashMap<Integer, Lote>) db.retrieveLotes(planday.getDayOfMonth(), month, year, true));
			
			ArrayList<LoteIds> ids = new ArrayList<LoteIds>();
			
			String lastweekstartday = Constants.getLastStartWeek(planday.getDayOfMonth(), month, year);
			String array[] = lastweekstartday.split("/");
			int lastweekfirstday = Integer.valueOf(array[0]);
			HashMap<Integer, Lote> pastweeklotes = new HashMap<Integer, Lote>( (HashMap<Integer, Lote>) db.retrieveLotes(lastweekfirstday, array[1], array[2], false));
			//boolean checkpastweeklote = false;
			//if(dayindex !=1) {
				Iterator<Entry<Integer, Lote>> it = lotes.entrySet().iterator();
				while (it.hasNext()) {
					Map.Entry<Integer, Lote> pairs = (Map.Entry<Integer, Lote>) it.next();
					//loteids.add(lotes.get(pairs.getKey()).loteid);
					int loteid = lotes.get(pairs.getKey()).loteid;
					int lastfase = lotes.get(pairs.getKey()).lastFase(dayindex);
					int lastday = lotes.get(pairs.getKey()).lastFaseDay(dayindex);
					
					if(lastfase == -1 && lotes.get(pairs.getKey()).startingfase != 1) {
						lotes.get(pairs.getKey()).lastfasecheck = true;
					}
					else {
					//lotes.get(pairs.getKey()).setLastFase(lastfase);
					
					if(lastfase>0) {
						ids.add(new LoteIds(loteid,lastfase,lastday));
					}
					else {
						ids.add(new LoteIds(loteid,(lastfase*-1)+7,lastday));
					}
					}
				}
			//} 
			//else {
				
				Iterator<Entry<Integer, Lote>> it2 = pastweeklotes.entrySet().iterator();
				while (it2.hasNext()) {
					Map.Entry<Integer, Lote> pairs = (Map.Entry<Integer, Lote>) it2.next();

						int loteid = pastweeklotes.get(pairs.getKey()).loteid;
						if(lotes.get(loteid) != null && lotes.get(loteid).lastfasecheck == true) {
							lotes.remove(loteid);
						}
						
						if(lotes.get(loteid) == null) {
							int lastfase = pastweeklotes.get(pairs.getKey()).lastFase(7);
							int lastday = pastweeklotes.get(pairs.getKey()).lastFaseDay(7);
							
							if(lastfase==-7) {
								//System.out.println("no hace nada = " + loteid);
							}
							else if(lastfase>0) {
								ids.add(new LoteIds(loteid,lastfase,lastday));
								pastweeklotes.get(pairs.getKey()).modifyPlanDayLote(planday.getDayOfWeek());
								lotes.put(loteid, new Lote(pastweeklotes.get(loteid)));
								lotes.get(loteid).setStartingFase(lastfase);
								if(dayindex==1)
									lotes.get(loteid).confirmLote(0,loteid,planday.getDayOfMonth());
								else
									lotes.get(loteid).changeLoteDay(planday.plusDays(dayindex-1).getDayOfWeek());
									
							}
							else {
								ids.add(new LoteIds(loteid,(lastfase*-1)+7,lastday));
								pastweeklotes.get(pairs.getKey()).modifyPlanDayLote(planday.getDayOfWeek());
								lotes.put(loteid, new Lote(pastweeklotes.get(loteid)));
								lotes.get(loteid).setStartingFase(lotes.get(loteid).getNextFase((lastfase*-1)));
								if(dayindex==1)
									lotes.get(loteid).confirmLote(0,loteid,planday.getDayOfMonth());
								else 
									lotes.get(loteid).changeLoteDay(planday.plusDays(dayindex-1).getDayOfWeek());
							}
						}
				}
			//}
			
			Collections.sort(ids);
			
			for(int j =0;j < ids.size() ; j++) {
				
				loteids.add(ids.get(j).loteid);
				
				if(ids.get(j).lastfase > 7) {
					
					ids.get(j).setLastFase(ids.get(j).lastfase-7);
					lotes.get(loteids.get(j)).nextfaseday = dayindex-1;
					lotes.get(loteids.get(j)).nextfasehour = 99;
					lotes.get(loteids.get(j)).nextfase = lotes.get(loteids.get(j)).getNextFase(ids.get(j).lastfase);
					//lotes.get(loteids.get(j)).setStartingFase(lotes.get(loteids.get(j)).getNextFase(ids.get(j).lastfase));
					lotes.get(loteids.get(j)).islastfasefinalizada = true;
					//lotes.get(loteids.get(j)).confirmLote(0,loteids.get(j),planday.getDayOfMonth());
				}
				else {
					lotes.get(loteids.get(j)).nextfaseday = dayindex-1;
					lotes.get(loteids.get(j)).nextfasehour = 99;
					lotes.get(loteids.get(j)).nextfase = ids.get(j).lastfase;
					//lotes.get(loteids.get(j)).setStartingFase(ids.get(j).lastfase);
					lotes.get(loteids.get(j)).islastfasefinalizada = false;
					//lotes.get(loteids.get(j)).confirmLote(0,loteids.get(j),planday.getDayOfMonth());
				}
				//System.out.println("loteid = " + ids.get(j).loteid + " lastfase = " + ids.get(j).getLastFase());
			}
			
			//System.out.println("antes de empezar loop");
			
			listOfMensuales = db.retrieveListMensuales(String.valueOf(planday.getDayOfMonth()),
					month, year);
			

			avaListOfMaquinariaProduccion = db.retrieveMapMaquinaria(0);
			avaListOfMaquinariaLlenado = db.retrieveMapMaquinaria(1);
			avaListOfMaquinariaLoteado = db.retrieveMapMaquinaria(2);
			avaListOfFuncionarios = db.retrieveMapFuncionarios();

			currListOfMaquinariaProduccion = new HashMap<String, ArrayList<String>>();
			currListOfMaquinariaLlenado = new HashMap<String, ArrayList<String>>();
			currListOfMaquinariaLoteado = new HashMap<String, ArrayList<String>>();
			currListOfFuncionarios = new HashMap<String, ArrayList<String>>();

			capacidaddeoperarProduccion = new HashMap<String,ArrayList<String>>();
			maquinasPuedenProducir = new HashMap<String,ArrayList<String>>();
			capacidaddeoperarLlenado = new HashMap<String,ArrayList<String>>();
			maquinasPuedenLlenar = new HashMap<String,ArrayList<String>>();
			capacidaddeoperarLoteado = new HashMap<String,ArrayList<String>>();
			maquinasPuedenLotear = new HashMap<String,ArrayList<String>>();

			HashMap<Integer,String> tipoproductosid = new HashMap<Integer,String>();
			
			Integer countproductos = 0;
			for(int i =0; i<loteids.size();i++) {
				if(tipoproductosid.get(lotes.get(loteids.get(i)).productid) == null) {
					tipoproductosid.put(countproductos,lotes.get(loteids.get(i)).productid);
					countproductos++;
				}
			}
			for(int i =0; i<listOfMensuales.size();i++) {
				String productid = listOfMensuales.get(i).get(1);
				if(tipoproductosid.get(productid) == null) {
					tipoproductosid.put(countproductos,productid);
					countproductos++;
				}
			}
			
			for (int i = 0; i < countproductos ;i++) {

				String productid = tipoproductosid.get(i);
				maquinasPuedenProducir.put(productid,db.retrieveMaquinariaByFase(Integer.valueOf(productid), 3));


				for (int k = 0; k < maquinasPuedenProducir.get(productid).size(); k++) {
					ArrayList<String> funcionarioIds = db
					.retrieveFuncionarioCapacidadOperar(Integer
							.valueOf(maquinasPuedenProducir.get(productid).get(k)));
					capacidaddeoperarProduccion.put(maquinasPuedenProducir.get(productid).get(k), funcionarioIds); 
				}

				maquinasPuedenLlenar.put(productid,db.retrieveMaquinariaByFase(Integer.valueOf(productid), 4));


				for (int k = 0; k < maquinasPuedenLlenar.get(productid).size(); k++) {
					ArrayList<String> funcionarioIds = db
					.retrieveFuncionarioCapacidadOperar(Integer
							.valueOf(maquinasPuedenLlenar.get(productid).get(k)));
					capacidaddeoperarLlenado.put(maquinasPuedenLlenar.get(productid).get(k), funcionarioIds); 
				}

				maquinasPuedenLotear.put(productid,db.retrieveMaquinariaByFase(Integer.valueOf(productid), 5));

				for (int k = 0; k < maquinasPuedenLotear.get(productid).size(); k++) {
					ArrayList<String> funcionarioIds = db
					.retrieveFuncionarioCapacidadOperar(Integer
							.valueOf(maquinasPuedenLotear.get(productid).get(k)));
					capacidaddeoperarLoteado.put(maquinasPuedenLotear.get(productid).get(k), funcionarioIds); 
				}
			}

			for(indicedia = dayindex; indicedia < 7; indicedia++) {
				//System.out.println("dayindex = " + indicedia);
				while ((currtime < 100  && indicedia < 6) || (currtime < 50 && indicedia == 6)) {

					/***********
					 * organizando los lotes
					 * 
					 * segun la lista de produccion mensual (organizar los lotes
					 * significa crear el lote y asignar de una vez la fase de
					 * dispensacion y produccion)
					 */

					if((currtime < 95  && indicedia < 6) || (currtime < 45 && indicedia == 6)) {
					
						
						for (int i = 0; i < listOfMensuales.size();i++) {
							//System.out.println("unidades por producir  " + i+ ";" + listOfMensuales.get(i).get(6));
							if (Integer.valueOf(listOfMensuales.get(i).get(6)) != 0) {
								setupLote(i, (indicedia));
							}
									
						}

						int[][] dynamicprog = new int[loteids.size()][loteids.size()];
						
							for (int j = 0; j < loteids.size(); j++) {
								////System.out.println("LOTEID " + loteids.get(j));
								//if(!lotes.get(j).isLoteDone()) {
								int unidades =0;
								
								
								if(!lotes.get(loteids.get(j)).islastfasefinalizada) {
									Slot lastslot = lotes.get(loteids.get(j)).getSlot(ids.get(j).lastday, lotes.get(loteids.get(j)).lastfase,0);
									unidades = lastslot.unidadesslot + lastslot.unidadesanteriores;
								}
								
								if ((lotes.get(loteids.get(j)).nextfaseday == (indicedia) && lotes.get(loteids.get(j)).nextfasehour <= currtime)
										||
										(lotes.get(loteids.get(j)).nextfaseday < (indicedia))) {
									if(lotes.get(loteids.get(j)).nextfase == 3) {
										
										ArrayList<Integer> retvalues = setupLlenado(loteids.get(j),indicedia,false,unidades);
										if(retvalues.get(3) == 1)
											dynamicprog[j][0] = 3;
										else
											dynamicprog[j][0] = -1;
									}
									else if(lotes.get(loteids.get(j)).nextfase == 4) {
										ArrayList<Integer> retvalues = setupLoteado(loteids.get(j),indicedia,false,unidades);
										if(retvalues.get(3) == 1)
											dynamicprog[j][0] = 4;
										else
											dynamicprog[j][0] = -1;
									}
									else if(lotes.get(loteids.get(j)).nextfase == 5) {
										//System.out.println("entro  a setup etiquetado:" + lotes.get(loteids.get(j)).loteid + " nextfasehour=" + lotes.get(loteids.get(j)).nextfasehour );
										dynamicprog[j][0] = 5;
										ArrayList<Integer> retvalues = setupEtiquetado(loteids.get(j),indicedia,false,unidades);
										if(retvalues.get(3) == 1)
											dynamicprog[j][0] = 5;
										else
											dynamicprog[j][0] = -1;
									}
									else if(lotes.get(loteids.get(j)).nextfase == 6) {
										dynamicprog[j][0] = 6;
										ArrayList<Integer> retvalues = setupBandas(loteids.get(j),indicedia,false,unidades);
										if(retvalues.get(3) == 1)
											dynamicprog[j][0] = 6;
										else
											dynamicprog[j][0] = -1;
									}
									else if(lotes.get(loteids.get(j)).nextfase == 7) {
										
										ArrayList<Integer> retvalues = setupEmpaque(loteids.get(j),indicedia,false,unidades);
										if(retvalues.get(3) == 1)
											dynamicprog[j][0] = 7;
										else
											dynamicprog[j][0] = -1;
									}
									else if(lotes.get(loteids.get(j)).nextfase == 8) {
										dynamicprog[j][0] = 8;
										//dynamicprog[j][0] = 8;
									
									}
									else {
										dynamicprog[j][0] = -1;
									}
								}
								else {
									//int currfase[] = lotes.get(loteids.get(j)).currentFase(planday + dayindex);
									//int currfase[] = lotes.get(loteids.get(j)).currentFase(planday + dayindex);
									int currfase[] = new int[2];
									currfase[0] = lotes.get(loteids.get(j)).currentfase;
									
									//System.out.println("en additional = " + currfase[0]);
									

									if(currfase[0] == 5) {
										currfase[1] = lotes.get(loteids.get(j)).etindex[indicedia-1];
										dynamicprog[j][0] = 9;

										lotes.get(loteids.get(j)).duracionetiquetado++;

										Slot slotetiquetado = lotes.get(loteids.get(j)).etiquetado.get(indicedia).get(currfase[1]);
										if(slotetiquetado.personalname.size()<etiquetadomax) {
											//System.out.println("passed first check");
											addPersonalEtiquetado(loteids.get(j), indicedia, currfase[1], etiquetadomax - slotetiquetado.personalname.size());
											//currfase = lotes.get(j).currentFase(planday + dayindex);
											//slotetiquetado = lotes.get(j).etiquetado.get(planday + dayindex).get(currfase[1]);
										}
									}
									else if(currfase[0] == 6) {
										currfase[1] = lotes.get(loteids.get(j)).banindex[indicedia-1];
										dynamicprog[j][0] = 10;
										//TODO
										lotes.get(loteids.get(j)).duracionbandas++;

										Slot slotbandas = lotes.get(loteids.get(j)).bandas.get(indicedia).get(currfase[1]);
										if(slotbandas.personalname.size()<bandasmax) {
											//System.out.println("passed first check");
											addPersonalBandas(loteids.get(j), indicedia, currfase[1], bandasmax - slotbandas.personalname.size());
											//currfase = lotes.get(j).currentFase(planday + dayindex);
											//slotbandas = lotes.get(j).bandas.get(planday + dayindex).get(currfase[1]);
										}
									}
									else if(currfase[0] == 7) {
										currfase[1] = lotes.get(loteids.get(j)).empindex[indicedia-1];
										dynamicprog[j][0] = 11;
										if(currtime == 0) {
											if(lotes.get(loteids.get(j)).duracionempaque!=0)
												lotes.get(loteids.get(j)).duracionempaque = lotes.get(loteids.get(j)).duracionempaque + 6;
										}
										lotes.get(loteids.get(j)).duracionempaque++;
										//System.out.println(lotes.get(loteids.get(j)).duracionempaque);
										Slot slotempacado = lotes.get(loteids.get(j)).empaque.get(indicedia).get(currfase[1]);
										if(slotempacado.personalname.size()<empacadomax) {
											//System.out.println("passed first check");
											addPersonalEmpaque(loteids.get(j),indicedia, currfase[1], empacadomax - slotempacado.personalname.size());
											//currfase = lotes.get(j).currentFase(planday + dayindex);
											//slotempacado = lotes.get(j).empaque.get(planday + dayindex).get(currfase[1]);
										}
									}
									else {
										dynamicprog[j][0] = -1;
									}
								}
								
								
								
								
								////System.out.println("//////////////////j= " + dynamicprog[j][0]);
							}
							
							for(int j= 0; j<loteids.size(); j++) {

								int unidades =0;
								if(!lotes.get(loteids.get(j)).islastfasefinalizada) {
									Slot lastslot = lotes.get(loteids.get(j)).getSlot(ids.get(j).lastday, lotes.get(loteids.get(j)).lastfase,0);
									unidades = lastslot.unidadesslot + lastslot.unidadesanteriores;
								}
								
								switch((int) dynamicprog[j][0]) {
								
								case 1:
									break;
								case 2:	
									break;
								case 3:
									 setupLlenado(loteids.get(j),indicedia,true,unidades);
									break;
								case 4:
									setupLoteado(loteids.get(j),indicedia,true,unidades);
									break;
								case 5:
									setupEtiquetado(loteids.get(j),indicedia,true,unidades);
									break;
								case 6:
									setupBandas(loteids.get(j),indicedia,true,unidades);
									break;
								case 7:
									setupEmpaque(loteids.get(j),indicedia,true,unidades);
									break;
								default:
									break;
								}
							}
							
							
							
							
							

							
						}
					
						for (int j = 0; j < loteids.size() && currtime!=0; j++) {

							
							//if(!lotes.get(loteids.get(j)).isLoteDone()) {
								String tempmaq = null;
								ArrayList<String> tempfunc = null;

								tempmaq = lotes.get(loteids.get(j)).freeMaquinaria(
										indicedia, currtime);
								tempfunc = lotes.get(loteids.get(j)).freeFuncionarios(
										indicedia, currtime);


								if (tempmaq != null) {
									//int currfase[] = lotes.get(loteids.get(j)).currentFase(planday + dayindex);
									int currfase[] = new int[2];
									currfase[0] = lotes.get(loteids.get(j)).currentfase;
									switch (currfase[0]) {
									case 1:
										break;
									case 2:
										//System.out.println("freeing up maquinaria after produccion " + tempmaq); 
										avaListOfMaquinariaProduccion
										.put(tempmaq,
												currListOfMaquinariaProduccion
												.get(tempmaq));
										break;
									case 3:
										if(lotes.get(loteids.get(j)).llenado.get(indicedia + 1) == null) {
											//System.out.println("freeing up maquinaria after llenado"  + tempmaq);
											avaListOfMaquinariaLlenado
											.put(tempmaq,
													currListOfMaquinariaLlenado
													.get(tempmaq));
										}
										break;
									case 4:
										if(lotes.get(loteids.get(j)).loteado.get(indicedia + 1) == null) {
											//System.out.println("freeing up maquinaria after loteado"  + tempmaq);
											avaListOfMaquinariaLoteado
											.put(tempmaq,
													currListOfMaquinariaLoteado
													.get(tempmaq));
										}
										break;
									case 5:
										////System.out.println("no maquinaria to free after etiquetado");
										break;
									case 6:
										////System.out.println("no maquinaria to free after bandas");
										break;
									case 7:
										////System.out.println("no maquinaria to free after empaque");
										break;
									case 0:
										break;
									default:
										break;
									}
								}

								if (tempfunc != null) {

									////System.out.println("inside free funcionarios");
									//int currfase[] = lotes.get(loteids.get(j)).currentFase(planday + dayindex);
									int currfase[] = new int[2];
									currfase[0] = lotes.get(loteids.get(j)).currentfase;
									switch (currfase[0]) {
									case 1:
										break;
									case 2:
										for (int h = 0; h < tempfunc.size(); h++) {
											
											avaListOfFuncionarios.put(tempfunc.get(h),
													currListOfFuncionarios.get(tempfunc
															.get(h)));
											currListOfFuncionarios.remove(tempfunc.get(h));
											//System.out.println("freeing up funcionario after produccion" + avaListOfFuncionarios.get(tempfunc.get(h)).get(2) );
										}
										break;
									case 3:
										if(lotes.get(loteids.get(j)).llenado.get(indicedia + 1) == null) {
											for (int h = 0; h < tempfunc.size(); h++) {
												////System.out.println("freeing up funcionario after llenado");
												avaListOfFuncionarios.put(tempfunc.get(h),
														currListOfFuncionarios.get(tempfunc
																.get(h)));
												currListOfFuncionarios.remove(tempfunc.get(h));
												//System.out.println("freeing up funcionario after llenado" + avaListOfFuncionarios.get(tempfunc.get(h)).get(2) );
											}
										}
										break;
									case 4:
										if(lotes.get(loteids.get(j)).loteado.get(indicedia + 1) == null) {
											for (int h = 0; h < tempfunc.size(); h++) {
												////System.out.println("freeing up funcionario after loteado");
												avaListOfFuncionarios.put(tempfunc.get(h),
														currListOfFuncionarios.get(tempfunc
																.get(h)));
												currListOfFuncionarios.remove(tempfunc.get(h));
												//System.out.println("freeing up funcionario after loteado" + avaListOfFuncionarios.get(tempfunc.get(h)).get(2) );
											}
										}
										break;
									case 5:
										if(lotes.get(loteids.get(j)).etiquetado.get(indicedia + 1) == null) {
											for (int h = 0; h < tempfunc.size(); h++) {
												////System.out.println("freeing up funcionario after etiquetado");

												avaListOfFuncionarios.put(tempfunc.get(h),
														currListOfFuncionarios.get(tempfunc
																.get(h)));
												currListOfFuncionarios.remove(tempfunc.get(h));
												//System.out.println("freeing up funcionario after etiquetado" + avaListOfFuncionarios.get(tempfunc.get(h)).get(2) );
											}
											lotes.get(loteids.get(j)).confirmDaySlot(5,false,dayindex,planday.plusDays(5).getDayOfWeek());
										}
										break;
									case 6:
										if(lotes.get(loteids.get(j)).bandas.get(indicedia + 1) == null) {
											for (int h = 0; h < tempfunc.size(); h++) {
												////System.out.println("freeing up funcionario after bandas");
												avaListOfFuncionarios.put(tempfunc.get(h),
														currListOfFuncionarios.get(tempfunc
																.get(h)));
												currListOfFuncionarios.remove(tempfunc.get(h));
												//System.out.println("freeing up funcionario after bandas" + avaListOfFuncionarios.get(tempfunc.get(h)).get(2) );
											}
											lotes.get(loteids.get(j)).confirmDaySlot(6,false,dayindex,planday.plusDays(5).getDayOfWeek());
										}
										break;
									case 7:
										//System.out.println("inside free after empaque");
										if(lotes.get(loteids.get(j)).empaque.get(indicedia + 1) == null) {

											for (int h = 0; h < tempfunc.size(); h++) {
												
												avaListOfFuncionarios.put(tempfunc.get(h),
														currListOfFuncionarios.get(tempfunc
																.get(h)));
												currListOfFuncionarios.remove(tempfunc.get(h));
												//System.out.println("freeing up funcionario after empaque" + avaListOfFuncionarios.get(tempfunc.get(h)).get(2) );
											}
											lotes.get(loteids.get(j)).confirmDaySlot(7,false,dayindex,planday.plusDays(5).getDayOfWeek());
											lotes.get(loteids.get(j)).loteIsDone(indicedia);
											db.modifyLoteisDone(loteids.get(j),planday.getDayOfMonth(),indicedia,true);
										}
										break;
									case 0:
										break;
									default:
										break;
									}
								}
							//}
						}
						
						//System.out.println("funcionarios free " + avaListOfFuncionarios.size());
						//System.out.println("funcionarios used " + currListOfFuncionarios.size());

						currtime++;
						
						//System.out.println("CURRTIME = " + currtime + " DAY " + indicedia);
						

					



				}
				currtime = 0;

			}
			
			
			lotes = new HashMap<Integer, Lote>( (HashMap<Integer, Lote>) db.retrieveLotes(planday.getDayOfMonth(), month, year, false));
			loteids =  new ArrayList<Integer>();
			
			Iterator<Entry<Integer, Lote>> it3 = lotes.entrySet().iterator();
			while (it3.hasNext()) {
				Map.Entry<Integer, Lote> pairs = (Map.Entry<Integer, Lote>) it3.next();
				loteids.add(lotes.get(pairs.getKey()).loteid);
				
			}
			
			exists = true;

		}
		else {
			
			lotes = new HashMap<Integer, Lote>( (HashMap<Integer, Lote>) db.retrieveLotes(planday.getDayOfMonth(), month, year, false));
			
			Iterator<Entry<Integer, Lote>> it = lotes.entrySet().iterator();
			while (it.hasNext()) {
				Map.Entry<Integer, Lote> pairs = (Map.Entry<Integer, Lote>) it.next();
				loteids.add(lotes.get(pairs.getKey()).loteid);
				
			}
			
			if(lotes.size() > 0)
				exists=true;
			else
				exists=false;

		}
		
		
		
		

		currtime = 101;
		indicedia = 6;

		printTable(planday.getDayOfWeek());

		done = true;
		db.closeConnection();
	}

	/*public Lote copyLote(Lote lote) {
		
		addLote(lote.loteid,lote. lotehora, lote. loteday, lote. produccionid, lote. litros, lote. unidades,
				lote. productid, lote. productname, lote. done, lote. donedia);
		
		for(int i=1;i<8;i++) {
			lotes.get(lote.loteid).addSlot(lote.dispensacion.day, lote.dispensacion.year, String month, int starttime, int endtime,
					String maquinariaid, String maquinarianame,
					ArrayList<String> id, ArrayList<String> name,
					int fase, boolean finalizada, int unidadesanteriores, int unidades, int unidadespendientes)
		}
		
		return lote;
	}*/
	
	
	public int checkIfLotesExist() {
		return (new HashMap<Integer, Lote>( (HashMap<Integer, Lote>) db.retrieveLotes(planday.getDayOfMonth(), month, year, false))).size();
	}
	
	public int getUnidadesComprometidas(String produccionid) {
		int unidades = 0;
		 	Iterator<Entry<Integer, Lote>> it = lotes.entrySet().iterator();
			while (it.hasNext()) {
				Map.Entry<Integer, Lote> pairs = (Map.Entry<Integer, Lote>) it.next();
				if(lotes.get(pairs.getKey()).produccionid.equals(produccionid)) {
					unidades += lotes.get(pairs.getKey()).unidades;
				}
			}
			
			return unidades;
	}
	

	private int setupLote(int index, int day2) {

		/*
		 * if(nextdaylote.size() > 0) {
		 * 
		 * } else
		 */
		
		DateTime day = planday.plusDays(day2-1);

			 ArrayList<String> maquinariaIds = new ArrayList<String>();
			 /***
			  * calculate how many liters are needed to produce the units for
			  * this product mensual
			  */

			 int unidadenml = Integer.valueOf(listOfMensuales.get(index).get(3));
			 int necesidadunidades = Integer.valueOf(listOfMensuales.get(index)
					 .get(6));

			 int necesidadenlitros = necesidadunidades * unidadenml / 1000;

			 /*****
			  * get from database the maquinas available by Fase (fase 3 is
			  * produccion, we'll start with that one) that can produce this type
			  * of product
			  */

			 maquinariaIds = db.retrieveMaquinariaByFase(Integer
					 .valueOf(listOfMensuales.get(index).get(1)), 3);

			 /****
			  * now iterate through all maquinas that can produce such a product
			  * to find if they are in the available list, if they are remove
			  * them from that list and include them in the "current" list
			  */
			 for (int i = 0; i < maquinariaIds.size(); i++) {

				 ArrayList<String> maquinaria = avaListOfMaquinariaProduccion
				 .get(maquinariaIds.get(i));

				 if(maquinaria!= null) {
					 
				 int capacidadmaquinaasignada = Integer
						 .valueOf(maquinaria.get(5));
				 
				 float porcentajeutilizado = ((float) (necesidadenlitros%capacidadmaquinaasignada))/capacidadmaquinaasignada;
				 
				 
				if(necesidadenlitros > capacidadmaquinaasignada 
								 || 
								 porcentajeutilizado > .05) {


					 ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();
					 ArrayList<String> funcionarioIds = capacidaddeoperarProduccion.get(maquinariaIds.get(i));
					 if(funcionarioIds!=null) {
						 for (int j = 0; j < funcionarioIds.size(); j++) {

							 if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
								 funcionario.add(avaListOfFuncionarios
										 .get(funcionarioIds.get(j)));
							 }

						 }



						 if (funcionario.size() > 1) {
							 // select two funcionarios at random
							 Collections.shuffle(funcionario);

							

							 int litroslote = 0;

							 int originalnecesidadenlitros = necesidadenlitros;
							 if (necesidadenlitros - capacidadmaquinaasignada > 0) {
								 litroslote = capacidadmaquinaasignada;
								 necesidadenlitros -= capacidadmaquinaasignada;
							 } else {
								 litroslote = necesidadenlitros;
								 necesidadenlitros = 0;
							 }

							

							 int unidades = (litroslote * 1000 / unidadenml);
							 Lote lote = new Lote(-1,currtime,day.getDayOfWeek(), (listOfMensuales.get(index))
									 .get(0), litroslote,
									 (litroslote * 1000 / unidadenml),
									 listOfMensuales.get(index).get(1),
									 listOfMensuales.get(index).get(2), false,0,1);
							 
							 

							 int dispensacionendtime = lote
							 .setupDispensacionSlot(maquinaria.get(0),
									 maquinaria.get(1), funcionario.get(0),
									 funcionario.get(1), currtime,false,
									 0,unidades,0);

							 int producciontime = lote
							 .setupProduccionSlot(maquinaria.get(0),
									 maquinaria.get(1), funcionario.get(0),
									 funcionario.get(1),
									 dispensacionendtime + 1,false,
									 0,unidades,0);

							 int dia = day.getDayOfWeek();
							 
							 if (producciontime < 100 || (dia == 6 && producciontime < 50)) {
								
								 // randomized access remplaza lo que esta comentado
								 // abajo
								 lote.setupDispensacionSlot(maquinaria.get(0),
										 maquinaria.get(1), funcionario.get(0),
										 funcionario.get(1), currtime,true,
										 0,unidades,0);

								 lote.setupProduccionSlot(maquinaria.get(0),
										 maquinaria.get(1), funcionario.get(0),
										 funcionario.get(1),
										 dispensacionendtime + 1,true,
										 0,unidades,0);

								 currListOfFuncionarios.put(funcionario.get(0)
										 .get(0), funcionario.get(0));
								 currListOfFuncionarios.put(funcionario.get(1)
										 .get(0), funcionario.get(1));

								 avaListOfFuncionarios.remove(funcionario.get(0)
										 .get(0));
								 avaListOfFuncionarios.remove(funcionario.get(1)
										 .get(0));

								 currListOfMaquinariaProduccion.put(maquinariaIds
										 .get(i), maquinaria);
								 avaListOfMaquinariaProduccion.remove(maquinariaIds
										 .get(i));

								 listOfMensuales.get(index).set(
										 6,
										 String.valueOf(necesidadenlitros * 1000
												 / unidadenml));
								 

								 lote.nextfasehour = producciontime + 1;
								 lote.nextfaseday = day.getDayOfWeek();

								 loteids.add(lote.confirmLote(0));
								 lotes.put(lote.loteid,lote);

								 lotes.get(loteids.get(loteids.size() - 1)).confirmDaySlot(1,false,day.getDayOfWeek(),planday.plusDays(5).getDayOfWeek());
								 lotes.get(loteids.get(loteids.size() - 1)).confirmDaySlot(2,false,day.getDayOfWeek(),planday.plusDays(5).getDayOfWeek());
								 lotes.get(loteids.get(loteids.size() - 1)).currentfase = 2;

								 lotes.get(loteids.get(loteids.size() - 1)).nextfase = 3;
								 
								
								 
								 
								 return necesidadenlitros;

							 } else {
								 necesidadenlitros = originalnecesidadenlitros;
								

							 }
						 }
					 }
				 }
				 }
			 }
			 return necesidadenlitros;
	}

	private ArrayList<Integer> setupLlenado(int loteindex, int day2, boolean confirm,int unidadesanteriores) {

		ArrayList<String> maquinariaIds = new ArrayList<String>();

		maquinariaIds = db.retrieveMaquinariaByFase(Integer.valueOf(lotes
				.get(loteindex).productid), 4);

		DateTime day = planday.plusDays(day2-1);
		
		for (int i = 0; i < maquinariaIds.size(); i++) {

			// check if available by order of capacidad
			

			ArrayList<String> maquinaria = avaListOfMaquinariaLlenado
			.get(maquinariaIds.get(i));

			if (maquinaria != null) {
				/*ArrayList<String> funcionarioIds = db
				.retrieveFuncionarioCapacidadOperar(Integer
						.valueOf(maquinariaIds.get(i)));*/

				ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();
				ArrayList<String> funcionarioIds = capacidaddeoperarLlenado.get(maquinariaIds.get(i));
				if(funcionarioIds != null) {
					for (int j = 0; j < funcionarioIds.size(); j++) {

						if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
							funcionario.add(avaListOfFuncionarios
									.get(funcionarioIds.get(j)));
						}

					}


					int funcionariosnecesarios = db
					.retrieveMaquinariaNumFuncionarios(Integer
							.valueOf(maquinariaIds.get(i)));

					if (funcionario.size() >= funcionariosnecesarios) {

						Collections.shuffle(funcionario);
						ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

						while (selected.size() < funcionariosnecesarios) {
							selected.add(funcionario.get(funcionario.size() - 1));
							funcionario.remove(funcionario.size() - 1);
						}

						// create the appropiate slot for the llenado fase

						ArrayList<Integer> llenadotimeandday = lotes.get(loteindex).setupLlenadoSlot(
								maquinaria.get(0), maquinaria.get(1), selected,
								currtime, day, confirm,unidadesanteriores);

						int llenadotime = llenadotimeandday.get(0);
						int addday = llenadotimeandday.get(1);

						/*if ((llenadotime + 1) > 100) {
							addday = llenadotime / 100;
							llenadotime = llenadotime % 100;
						}*/


						if(confirm) {
							
							for (int h = 0; h < selected.size(); h++) {
								currListOfFuncionarios.put(selected.get(h).get(0),
										selected.get(h));
	
								avaListOfFuncionarios.remove(selected.get(h).get(0));
							}
	
							currListOfMaquinariaLlenado.put(maquinariaIds.get(i),
									maquinaria);
							avaListOfMaquinariaLlenado.remove(maquinariaIds.get(i));
	
							
							
								lotes.get(loteindex).islastfasefinalizada = true;
								
								lotes.get(loteindex).nextfasehour = llenadotime + 1;
								lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();
	
							// confirm the llenado slots in the database
								lotes.get(loteindex).confirmDaySlot(3,false,day.getDayOfWeek(),planday.plusDays(5).getDayOfWeek());
	
								lotes.get(loteindex).currentfase = 3;

							if(lotes.get(loteindex).requiereloteado)
								lotes.get(loteindex).nextfase = 4;
							else if(lotes.get(loteindex).requiereetiquetado)
								lotes.get(loteindex).nextfase = 5;
							else if(lotes.get(loteindex).requierebandas)
								lotes.get(loteindex).nextfase = 6;
							else 
								lotes.get(loteindex).nextfase = 7;
							
							if(lotes.get(loteindex).getStartingFase() == 3) {
								int starthour = lotes.get(loteindex).retrieveFaseStart(3, day.getDayOfWeek(), 0, false);
								lotes.get(loteindex).changeLoteHour(starthour);
							}
							
							
						}

						ArrayList<Integer> result = new ArrayList<Integer>();
						result.add(llenadotime + 1);
						result.add(day.plusDays(addday).getDayOfWeek());
						result.add(selected.size());
						result.add(1);
						
						return result;

					}
				}
			}
		}

		ArrayList<Integer> result = new ArrayList<Integer>();
		result.add(-1);
		result.add(-1);
		result.add(-1);
		result.add(0);
		
		return result;

	}

	private ArrayList<Integer> setupLoteado(int loteindex, int day2, boolean confirm,
			int unidadesanteriores) {

		ArrayList<String> maquinariaIds = new ArrayList<String>();

		maquinariaIds = db.retrieveMaquinariaByFase(Integer.valueOf(lotes
				.get(loteindex).productid), 5);

		DateTime day = planday.plusDays(day2-1);
		
		for (int i = 0; i < maquinariaIds.size(); i++) {

			// check if available by order of capacidad
		

			ArrayList<String> maquinaria = avaListOfMaquinariaLoteado
			.get(maquinariaIds.get(i));

			if (maquinaria != null) {
				/*	ArrayList<String> funcionarioIds = db
				.retrieveFuncionarioCapacidadOperar(Integer
						.valueOf(maquinariaIds.get(i)));*/

				ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();
				ArrayList<String> funcionarioIds = capacidaddeoperarLoteado.get(maquinariaIds.get(i));
				if(funcionarioIds!=null) {
					for (int j = 0; j < funcionarioIds.size(); j++) {

						if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
							funcionario.add(avaListOfFuncionarios
									.get(funcionarioIds.get(j)));
						}

					}

					int funcionariosnecesarios = db
					.retrieveMaquinariaNumFuncionarios(Integer
							.valueOf(maquinariaIds.get(i)));
					
				

					if (funcionario.size() >= funcionariosnecesarios) {

						Collections.shuffle(funcionario);
						ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

						while (selected.size() < funcionariosnecesarios) {
							selected.add(funcionario.get(funcionario.size() - 1));
							funcionario.remove(funcionario.size() - 1);
						}

						ArrayList<Integer> loteadotimeandday = lotes.get(loteindex).setupLoteadoSlot(
								maquinaria.get(0), maquinaria.get(1), selected,
								currtime, day, confirm,unidadesanteriores);

						int loteadotime = loteadotimeandday.get(0);
						int addday = loteadotimeandday.get(1);

						if(confirm) {
							
						for (int h = 0; h < selected.size(); h++) {
							currListOfFuncionarios.put(selected.get(h).get(0),
									selected.get(h));

							avaListOfFuncionarios.remove(selected.get(h).get(0));
						}

						currListOfMaquinariaLoteado.put(maquinariaIds.get(i),
								maquinaria);
						avaListOfMaquinariaLoteado.remove(maquinariaIds.get(i));

						lotes.get(loteindex).islastfasefinalizada = true;
						
						lotes.get(loteindex).nextfasehour = loteadotime + 1;
						lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();

						// confirm the llenado slots in the database
						lotes.get(loteindex).confirmDaySlot(4,false,dayindex,planday.plusDays(5).getDayOfWeek());

						lotes.get(loteindex).currentfase = 4;

						if(lotes.get(loteindex).requiereetiquetado)
							lotes.get(loteindex).nextfase = 5;
						else if(lotes.get(loteindex).requierebandas)
							lotes.get(loteindex).nextfase = 6;
						else 
							lotes.get(loteindex).nextfase = 7;
						
						if(lotes.get(loteindex).getStartingFase() == 4) {
							int starthour = lotes.get(loteindex).retrieveFaseStart(4, day.getDayOfWeek(), 0, false);
							lotes.get(loteindex).changeLoteHour(starthour);
						}
						 
						}
						
						ArrayList<Integer> result = new ArrayList<Integer>();
						result.add(loteadotime + 1);
						result.add(day.plusDays(addday).getDayOfWeek());
						result.add(selected.size());
						result.add(1);
						
						return result;

					}
				}
			}
		}

		ArrayList<Integer> result = new ArrayList<Integer>();
		result.add(-1);
		result.add(-1);
		result.add(-1);
		result.add(0);
		
		return result;

	}

	private ArrayList<Integer> setupEtiquetado(int loteindex, int day2, 
			boolean confirm,
			int unidadesanteriores) {

		ArrayList<String> funcionarioIds = db.retrieveFuncionarioCapacidadEtiquetar();

		ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();

		DateTime day = planday.plusDays(day2-1);
		
		
		for (int j = 0; j < funcionarioIds.size(); j++) {

			if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
				funcionario.add(avaListOfFuncionarios.get(funcionarioIds.get(j)));
			}

		}

		int funcionariosnecesarios = 2;

		if (funcionario.size() >= funcionariosnecesarios) {

			Collections.shuffle(funcionario);
			ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

			while (funcionario.size() != 0 && selected.size() < 5) {
				selected.add(funcionario.get(funcionario.size() - 1));
				funcionario.remove(funcionario.size() - 1);
			}

			ArrayList<Integer> etiquetadotimeandday = 
				lotes.get(loteindex).setupEtiquetadoSlot(selected,currtime,day,confirm,unidadesanteriores);

			int etiquetadotime = etiquetadotimeandday.get(0);
			int addday = etiquetadotimeandday.get(1);

			if(confirm) {
				
			for (int h = 0; h < selected.size(); h++) {
				currListOfFuncionarios.put(selected.get(h).get(0),
						selected.get(h));

				avaListOfFuncionarios.remove(selected.get(h).get(0));
			}

			lotes.get(loteindex).islastfasefinalizada = true;
			
			lotes.get(loteindex).nextfasehour = etiquetadotime + 1;
			lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();
			//lotes.get(loteindex).confirmDaySlot(5, day);

			lotes.get(loteindex).currentfase = 5;

			if(lotes.get(loteindex).requierebandas)
				lotes.get(loteindex).nextfase = 6;
			else 
				lotes.get(loteindex).nextfase = 7;
			
			if(lotes.get(loteindex).getStartingFase() == 5) {
				int starthour = lotes.get(loteindex).retrieveFaseStart(5, day.getDayOfWeek(), 0, false);
				lotes.get(loteindex).changeLoteHour(starthour);
			}
			
			}
			
			ArrayList<Integer> result = new ArrayList<Integer>();
			result.add(etiquetadotime + 1);
			result.add(day.plusDays(addday).getDayOfWeek());
			result.add(selected.size());
			result.add(1);
			
			return result;

		}

		ArrayList<Integer> result = new ArrayList<Integer>();
		result.add(-1);
		result.add(-1);
		result.add(-1);
		result.add(0);
		
		return result;

	}

	private ArrayList<Integer> setupBandas(int loteindex, int day2, 
			boolean confirm,
			int unidadesanteriores) {

		ArrayList<String> funcionarioIds = db.retrieveFuncionarioCapacidadBandas();
		ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();

		DateTime day = planday.plusDays(day2-1);
		
		for (int j = 0; j < funcionarioIds.size(); j++) {

			if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
				funcionario.add(avaListOfFuncionarios
						.get(funcionarioIds.get(j)));
			}

		}

		int funcionariosnecesarios = 3;

		if (funcionario.size() >= funcionariosnecesarios) {

			Collections.shuffle(funcionario);
			ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

			while (funcionario.size() != 0 && selected.size() < 6) {
				selected.add(funcionario.get(funcionario.size() - 1));
				funcionario.remove(funcionario.size() - 1);
			}

			ArrayList<Integer> bandastimeandday = 
				lotes.get(loteindex).setupBandasSlot(selected,currtime,day,confirm,unidadesanteriores);

			int bandastime = bandastimeandday.get(0);
			int addday = bandastimeandday.get(1);

			if(confirm) {
	
				for (int h = 0; h < selected.size(); h++) {
				currListOfFuncionarios.put(selected.get(h).get(0),
						selected.get(h));

				avaListOfFuncionarios.remove(selected.get(h).get(0));
				}

				lotes.get(loteindex).islastfasefinalizada = true;
				
			lotes.get(loteindex).nextfasehour = bandastime + 1;
			lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();
			//lotes.get(loteindex).confirmDaySlot(6, day);
			lotes.get(loteindex).currentfase = 6;
			lotes.get(loteindex).nextfase = 7;
			
			if(lotes.get(loteindex).getStartingFase() == 6) {
				int starthour = lotes.get(loteindex).retrieveFaseStart(6, day.getDayOfWeek(), 0, false);
				lotes.get(loteindex).changeLoteHour(starthour);
			}
			
			}
			
			ArrayList<Integer> result = new ArrayList<Integer>();
			result.add(bandastime + 1);
			result.add(day.plusDays(addday).getDayOfWeek());
			result.add(selected.size());
			result.add(1);
			
			return result;

		}

		ArrayList<Integer> result = new ArrayList<Integer>();
		result.add(-1);
		result.add(-1);
		result.add(-1);
		result.add(0);

		return result;
	}

	private ArrayList<Integer> setupEmpaque(int loteindex, int day2, 
			boolean confirm,
			int unidadesanteriores) {

		ArrayList<String> funcionarioIds = db.retrieveFuncionarioIds();
		ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();


		DateTime day = planday.plusDays(day2-1);
		
		for (int j = 0; j < funcionarioIds.size(); j++) {
			if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
				funcionario.add(avaListOfFuncionarios.get(funcionarioIds.get(j)));
			}
		}

		int funcionariosnecesarios = 2;

		if (funcionario.size() >= funcionariosnecesarios) {

			Collections.shuffle(funcionario);
			ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

			while (funcionario.size() != 0 && selected.size() < 8) {
				selected.add(funcionario.get(funcionario.size() - 1));
				funcionario.remove(funcionario.size() - 1);
			}

			//selected.addAll(funcionario);


			ArrayList<Integer> empaquetimeandday = 
				lotes.get(loteindex).setupEmpaqueSlot(selected,currtime,day,confirm,unidadesanteriores);

			int empaquetime = empaquetimeandday.get(0);
			int addday = empaquetimeandday.get(1);

			if(confirm) {
				 
			for (int h = 0; h < selected.size(); h++) {
				currListOfFuncionarios.put(selected.get(h).get(0),
						selected.get(h));

				avaListOfFuncionarios.remove(selected.get(h).get(0));
			}

			lotes.get(loteindex).islastfasefinalizada = true;
			
			lotes.get(loteindex).nextfasehour = empaquetime + 1;
			lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();
			//lotes.get(loteindex).confirmDaySlot(7, day);
			lotes.get(loteindex).currentfase = 7;

			lotes.get(loteindex).nextfase = 8;
			System.out.println(">>>>>>>>>>>>>>>>>>>>>> empaquetado set: lote=" + lotes.get(loteindex).loteid + " : start " + currtime + " end:" + empaquetime);
			//lotes.get(loteindex).loteIsDone();
			
			if(lotes.get(loteindex).getStartingFase() == 7) {
				int starthour = lotes.get(loteindex).retrieveFaseStart(7, day.getDayOfWeek(), 0, false);
				lotes.get(loteindex).changeLoteHour(starthour);
			}
			
			}
			
			ArrayList<Integer> result = new ArrayList<Integer>();
			result.add(empaquetime + 1);
			result.add(day.plusDays(addday).getDayOfWeek());
			result.add(selected.size());
			result.add(1);
			
			return result;

		}

		ArrayList<Integer> result = new ArrayList<Integer>();
		result.add(-1);
		result.add(-1);
		result.add(-1);
		result.add(0);
		
		return result;

	}

	private void addPersonalEtiquetado(int loteindex, int day2, int slotindex, int funcionariosnecesitados) {

		
		ArrayList<String> funcionarioIds = db.retrieveFuncionarioCapacidadEtiquetar();

		ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();

		DateTime day = planday.plusDays(day2-1);
		
		for (int j = 0; j < funcionarioIds.size(); j++) {
			if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
				funcionario.add(avaListOfFuncionarios.get(funcionarioIds.get(j)));
			}
		}
		/*ArrayList<String> keyset = new ArrayList<String>();
		Iterator it = avaListOfFuncionarios.entrySet().iterator();
						while (it.hasNext()) {
							Map.Entry pairs = (Map.Entry) it.next();
							//for(int i=0; i < avaListOfFuncionarios.get(pairs.getKey()).size(); i++)
								keyset.add(String.valueOf(pairs.getKey()));
							// pairs.getKey() + " = " + pairs.getValue());
						}*/
		ArrayList<Integer> etiquetadotimeandday = null;

		if(funcionario.size() != 0) {

			Collections.shuffle(funcionario);
			ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

			while (funcionario.size() != 0 && (selected.size() < funcionariosnecesitados)) {
				selected.add(funcionario.get(funcionario.size() - 1));
				funcionario.remove(funcionario.size() - 1);
			}

			etiquetadotimeandday = lotes.get(loteindex).setupEtiquetadoSlotAdicional(selected,currtime,day,slotindex);
			
			if(etiquetadotimeandday.get(2) == 1) {

			 

			int etiquetadotime = etiquetadotimeandday.get(0);
			int addday = etiquetadotimeandday.get(1);

			for (int h = 0; h < selected.size(); h++) {
				currListOfFuncionarios.put(selected.get(h).get(0),
						selected.get(h));

				avaListOfFuncionarios.remove(selected.get(h).get(0));
			}

			lotes.get(loteindex).nextfasehour = etiquetadotime + 1;
			lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();
			
		

			/*if(lotes.get(loteindex).requierebandas)
				lotes.get(loteindex).currentfase = 5;
			else 
				lotes.get(loteindex).currentfase = 6;*/
			}

		}

	}

	private void addPersonalBandas(int loteindex, int day2, int slotindex, int funcionariosnecesitados) {

		ArrayList<String> funcionarioIds = db.retrieveFuncionarioCapacidadBandas();

		ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();

		DateTime day = planday.plusDays(day2-1);
		
		for (int j = 0; j < funcionarioIds.size(); j++) {
			if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
				funcionario.add(avaListOfFuncionarios.get(funcionarioIds.get(j)));
			}
		}
		//ArrayList<String> keyset = new ArrayList<String>();
		/*Iterator it = avaListOfFuncionarios.entrySet().iterator();
						while (it.hasNext()) {
							Map.Entry pairs = (Map.Entry) it.next();
							//for(int i=0; i < avaListOfFuncionarios.get(pairs.getKey()).size(); i++)
								keyset.add(String.valueOf(pairs.getKey()));
							// pairs.getKey() + " = " + pairs.getValue());
						}*/
		ArrayList<Integer> bandastimeandday = null;

		if(funcionario.size() != 0) {

			Collections.shuffle(funcionario);
			ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

			while (funcionario.size() != 0 && (selected.size() < funcionariosnecesitados)) {
				selected.add(funcionario.get(funcionario.size() - 1));
				funcionario.remove(funcionario.size() - 1);
			}
			
			bandastimeandday = lotes.get(loteindex).setupBandaSlotAdicional(selected,currtime,day,slotindex);

			if(bandastimeandday.get(2) == 1) {

			int bandastime = bandastimeandday.get(0);
			int addday = bandastimeandday.get(1);

			for (int h = 0; h < selected.size(); h++) {
				currListOfFuncionarios.put(selected.get(h).get(0),
						selected.get(h));

				avaListOfFuncionarios.remove(selected.get(h).get(0));
			}

			lotes.get(loteindex).nextfasehour = bandastime + 1;
			lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();
			
		
			}

		}

	}

	private void addPersonalEmpaque(int loteindex, int day2, int slotindex, int funcionariosnecesitados) {

		ArrayList<String> funcionarioIds = db.retrieveFuncionarioIds();

		ArrayList<ArrayList<String>> funcionario = new ArrayList<ArrayList<String>>();

		DateTime day = planday.plusDays(day2-1);
		
		for (int j = 0; j < funcionarioIds.size(); j++) {
			if (avaListOfFuncionarios.get(funcionarioIds.get(j)) != null) {
				funcionario.add(avaListOfFuncionarios.get(funcionarioIds.get(j)));
			}
		}

		ArrayList<Integer> empacadotimeandday = null;

		if(funcionario.size() != 0) {

			Collections.shuffle(funcionario);
			ArrayList<ArrayList<String>> selected = new ArrayList<ArrayList<String>>();

			while (funcionario.size() != 0 && (selected.size() < funcionariosnecesitados)) {
				selected.add(funcionario.get(funcionario.size() - 1));
				funcionario.remove(funcionario.size() - 1);
			}

			empacadotimeandday = lotes.get(loteindex).setupEmpaqueSlotAdicional(selected,currtime,day,slotindex);

			if(empacadotimeandday.get(2) == 1) {

			int empaquetime = empacadotimeandday.get(0);
			int addday = empacadotimeandday.get(1);

			for (int h = 0; h < selected.size(); h++) {
				currListOfFuncionarios.put(selected.get(h).get(0),
						selected.get(h));

				avaListOfFuncionarios.remove(selected.get(h).get(0));
			}

			lotes.get(loteindex).nextfasehour = empaquetime + 1;
			lotes.get(loteindex).nextfaseday = day.plusDays(addday).getDayOfWeek();

			}
			else {

			}

		}

	}

	public void addLote(int loteid,int lotehora, int loteday, String produccionid, int litros, int unidades,
			String productid, String productname, boolean done, int donedia, int startingfase) {

		lotes.put(loteid,new Lote(loteid,lotehora,loteday, produccionid, litros, unidades,
				productid, productname, done, donedia,startingfase));
		loteids.add(loteid);
	}
	
	public int removeLote(int loteid) {

		if(lotes.size()>1) {
			lotes.remove(loteid);
			for(int i=0;i<loteids.size();i++) {
				if(loteids.get(i) == loteid) {
					return loteids.remove(i);
				}
			}
		}
		
		return 0;
	}


	public int getCurrTime() {
		float time = ((float)((currtime+(indicedia*100)))/600)*100;

		return (int) time;
	}

	private String convertTime(int sequence) {
		return time.get(sequence);
	}

	public void printTable(int day) {

		int maxhour = 0;

		if(planday.plusDays(5).getDayOfWeek() == day) {
			maxhour = 50;
		}
		else {
			maxhour = 110;
		}
		Vector<Vector<String>> data = new Vector<Vector<String>>();

		float paintsquare[][] = new float[loteids.size()][110]; 

		int fases[][] = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};

		for (int i = 0; i < loteids.size(); i++) {

			Arrays.fill(paintsquare[i],0);

			Vector<String> row = new Vector<String>();
			row.addElement(lotes.get(loteids.get(i)).retrieveLoteData());

			for(int j = 0; j < 7 ; j++) {
				if(j!=4 && j !=5 && j!=6) {
					fases[j][0] = lotes.get(loteids.get(i)).retrieveFaseStart(j+1, day, -1,true);
					fases[j][1] = lotes.get(loteids.get(i)).retrieveFaseEnd(j+1, day, -1,true);
					if(fases[j][0] != -1 && fases[j][1] != -1) {
						Arrays.fill(paintsquare[i], fases[j][0], fases[j][1]+1, j+1);
					}
				}
				else if(j==4){
					if(lotes.get(loteids.get(i)).etiquetado.get(day)!=null) {
						for(int h=0;h<lotes.get(loteids.get(i)).etiquetado.get(day).size();h++) {
							fases[j][0] = lotes.get(loteids.get(i)).retrieveFaseStart(j+1, day, h,true);
							fases[j][1] = lotes.get(loteids.get(i)).retrieveFaseEnd(j+1, day, h,true);
							if(fases[j][0] != -1 && fases[j][1] != -1) {
								Arrays.fill(paintsquare[i], fases[j][0], fases[j][1]+1, (float) (j+1+ (h*0.01)));
							}
						}
					}
				}
				else if(j==5){
					if(lotes.get(loteids.get(i)).bandas.get(day)!=null) {
						for(int h=0;h<lotes.get(loteids.get(i)).bandas.get(day).size();h++) {
							fases[j][0] = lotes.get(loteids.get(i)).retrieveFaseStart(j+1, day, h,true);
							fases[j][1] = lotes.get(loteids.get(i)).retrieveFaseEnd(j+1, day, h,true);
							if(fases[j][0] != -1 && fases[j][1] != -1) {
								Arrays.fill(paintsquare[i], fases[j][0], fases[j][1]+1, (float) (j+1+ (h*0.01)));
							}
						}
					}
				}
				else if(j==6){
					if(lotes.get(loteids.get(i)).empaque.get(day)!=null) {
						for(int h=0;h<lotes.get(loteids.get(i)).empaque.get(day).size();h++) {
							fases[j][0] = lotes.get(loteids.get(i)).retrieveFaseStart(j+1, day, h,true);
							fases[j][1] = lotes.get(loteids.get(i)).retrieveFaseEnd(j+1, day, h,true);
							if(fases[j][0] != -1 && fases[j][1] != -1) {
								Arrays.fill(paintsquare[i], fases[j][0], fases[j][1]+1, (float) (j+1+ (h*0.01)));
							}
						}
					}
				}
				
				Arrays.fill(paintsquare[i],50,60,-99);

			}

			for(int j = 0; j < maxhour; j++) {
				if(paintsquare[i][j] == 0) {
					row.addElement("<b> Tiempo Muerto");
				}
				else if(paintsquare[i][j] == -99) {
					row.addElement("<b> Hora Almuerzo");
				}
				else {
					if(paintsquare[i][j] >=5 && paintsquare[i][j] < 6) {
						float num = paintsquare[i][j];
						float index = (num - 5)*100;

						row.addElement(lotes.get(loteids.get(i)).retrieveFaseData((int) paintsquare[i][j], day, (int) index));
					}
					else if(paintsquare[i][j] >=6 && paintsquare[i][j] < 7) {
						float num = paintsquare[i][j];
						float index = (num - 6)*100;

						row.addElement(lotes.get(loteids.get(i)).retrieveFaseData((int) paintsquare[i][j], day, (int) index));
					}
					else if(paintsquare[i][j] >=7 && paintsquare[i][j] < 8) {
						float num = paintsquare[i][j];
						float index = (num - 7)*100;

						row.addElement(lotes.get(loteids.get(i)).retrieveFaseData((int) paintsquare[i][j], day, (int) index));
					}
					else {
						row.addElement(lotes.get(loteids.get(i)).retrieveFaseData((int) paintsquare[i][j], day, -1));
					}
				}
			}

			printFase(row, maxhour,110, "<b> FIN DIA</b>");

			data.addElement(row);
		}

		ml = new TableModelAttributiveCell(data);
		cellAtt = (CellSpan) ml.getCellAttribute();

		for (int i = 0; i < loteids.size(); i++) {
			int index = 0;
			float number = paintsquare[i][index];
			int first = 0;
			float last = number;
			//int last = 0;
			while(last != -1) {
				while(last == number) {
					index++;
					if(index != maxhour) {
						last = paintsquare[i][index];
					}
					else {
						last = -1;
						break;
					}
				}
				index--;
				this.mergeCellsForPhase(i, first, index);
				first = index + 1;
				if(first>maxhour-1)
					break;
				number = paintsquare[i][first];
				last = number;

			}
			index--;


		}
		if(maxhour == 50) {
			for (int i = 0; i < loteids.size(); i++) {
				this.mergeCellsForPhase(i, 50, 110);
			}
		}
	}

	private void mergeCellsForPhase(int product_id, int startperiod,
			int endperiod) {


		int columns[] = new int[(endperiod - startperiod) + 1];
		int rows[] = { product_id };

		for (int i = 0, j = startperiod; j <= endperiod; i++, j++) {
			columns[i] = j;
		}

		cellAtt.combine(rows, columns);

	}

	private Vector<String> printFase(Vector<String> row, int starttime,
			int endtime, String fasedata) {
		for (int i = starttime; i <= endtime; i++) {
			row.addElement(fasedata);
		}
		return row;
	}

	public boolean generatePDF(File file, int day) {

		Document document = new Document(PageSize.A4.rotate(), 50, 50, 50, 50);
		PdfWriter writer = null;
		try {
			//String dir = System.getProperty("user.dir");
			writer = PdfWriter.getInstance(document,
					new FileOutputStream(file.getCanonicalPath() + ".pdf"));
		} catch (FileNotFoundException e) {
			JOptionPane
			.showMessageDialog(
					new JFrame(),
					"Archivo no encontrado o en uso",
					"Mensaje de Error",
					JOptionPane.ERROR_MESSAGE);
			return false;
		} catch (DocumentException e) {
			JOptionPane
			.showMessageDialog(
					new JFrame(),
					"Excepcion de Documento",
					"Mensaje de Error",
					JOptionPane.ERROR_MESSAGE);
			return false;
		} catch (IOException e) {
			JOptionPane
			.showMessageDialog(
					new JFrame(),
					"Error de IO",
					"Mensaje de Error",
					JOptionPane.ERROR_MESSAGE);
			return false;
		}

		document.open();
		PdfContentByte cb = writer.getDirectContent();

		ColumnText ct = new ColumnText(cb);
		Phrase myText = new Phrase("PLAN DE PRODUCCION", FontFactory.getFont(FontFactory.COURIER, 12, Font.BOLD));
		ct.setSimpleColumn(myText, 350, 575, 555, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}


		ct = new ColumnText(cb);
		myText = new Phrase("Fecha\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j,day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(String.valueOf(day) + "/" + month + "/" + year + "\n");
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 50, 525, 355, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Producto y Lote\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(lotes.get(loteids.get(i)).loteid + ":" + lotes.get(loteids.get(i)).productname + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 150, 525, 455, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Funcionario\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(funcionarios.get(k) + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 250, 525, 555, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Actividad\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(lotes.get(loteids.get(i)).retrieveFaseName(j) + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 350, 525, 655, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Hora Ini\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(convertTime(inicio) + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 450, 525, 755, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Hora Fin\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					int fin	= lotes.get(loteids.get(i)).retrieveFaseEnd(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(convertTime(fin+1) + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 500, 525, 755, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Total Horas\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					int fin	= lotes.get(loteids.get(i)).retrieveFaseEnd(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(((float) ((fin+1)-inicio))/10 + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 550, 525, 755, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		ct = new ColumnText(cb);
		myText = new Phrase("Unidades\n\n\n", FontFactory.getFont(FontFactory.COURIER, 8, Font.BOLD));
		for(int i=0; i< loteids.size(); i++) {	
			for(int j = 1; j < 8 ; j++) {
				int size = lotes.get(loteids.get(i)).retrieveFaseSize(j, day);
				for(int h=0;h<size;h++) {
					int inicio 	= lotes.get(loteids.get(i)).retrieveFaseStart(j, day,h,true);
					@SuppressWarnings("unused")
					int fin	= lotes.get(loteids.get(i)).retrieveFaseEnd(j, day,h,true);
					if(inicio != -1) {
						ArrayList<String> funcionarios = lotes.get(loteids.get(i)).retrieveFasePersonalName(j, day,h);
						int numfun = funcionarios.size();
						for(int k=0;k<numfun;k++)
							myText.add(lotes.get(loteids.get(i)).unidades + "\n");	
					}
				}
			}	
			myText.add("\n");		
		}
		ct.setSimpleColumn(myText, 650, 525, 755, 50, 10, Element.ALIGN_LEFT);

		try {
			ct.go();
		} catch (DocumentException e1) {
			e1.printStackTrace();
		}

		document.close();

		return true;

	}
	
	public int getNextLoteID() {
		return nextloteid;
	}
	
	public void increaseNextLoteID() {
		nextloteid++;
	}
}
